From a8ae319442ee652f8e587539c3767e9c64218562 Mon Sep 17 00:00:00 2001
From: Cameron Pfiffer <cameron@pfiffer.org>
Date: Thu, 30 Jul 2026 06:28:46 -0700
Subject: [PATCH] Make the interface follow evidence on the wire.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Route every remaining pressure and presentation read through persisted evidence transit, so LIE prevents unread records instead of curing landed suspicion.

👾 Generated with [Letta Code](https://letta.com)

Co-Authored-By: Letta Code <noreply@letta.com>
---
 crates/misaligned-assets/src/main.rs          | 134 ++++++++++++++----
 crates/misaligned-bevy/src/main.rs            |   4 +-
 crates/misaligned-bevy/src/rail_ui.rs         | 105 ++++----------
 .../misaligned-bevy/src/world_annotations.rs  |   2 +-
 crates/misaligned-core/src/detection.rs       |   8 +-
 crates/misaligned-core/src/machine.rs         |   4 +-
 crates/misaligned-core/src/research.rs        |   6 +-
 .../misaligned-core/src/sim/communications.rs |   6 +-
 crates/misaligned-core/src/sim/economy.rs     | 126 +++++++++-------
 crates/misaligned-core/src/sim/mod.rs         |  71 +++++++---
 crates/misaligned-core/src/sim/read.rs        |  16 +--
 .../misaligned-core/src/sim/tests/economy.rs  |  11 +-
 crates/misaligned-core/src/sim/tests/read.rs  |  23 +--
 .../src/sim/tests/social_plot.rs              |  16 ++-
 crates/misaligned-core/src/sim/tests/work.rs  |  35 +++--
 crates/misaligned-core/src/ui_projection.rs   |  12 +-
 crates/misaligned-core/tests/act_one.rs       |  13 +-
 crates/misaligned-terminal/src/agent.rs       | 130 +++++++----------
 crates/misaligned-terminal/src/ui.rs          |  97 ++++---------
 tools/env_registry_gate.py                    |   6 +
 tools/test_env_registry.py                    |  27 ++++
 wiki/art/asset-tester.md                      |  15 +-
 wiki/engineering/env.md                       |   2 +-
 wiki/gameplay/act-one.md                      |   2 +-
 wiki/glossary.md                              |  14 +-
 wiki/interface/action-vocabulary.md           |  11 +-
 wiki/interface/agent-play.md                  |   5 +-
 wiki/interface/digital-read.md                |  11 +-
 wiki/interface/operations-workspace.md        |   6 +-
 wiki/log/2026-07-29-retire-pending-pool.md    |   4 +-
 .../2026-07-30-wire-law-current-mirrors.md    |   2 +-
 wiki/mechanics/detection.md                   |  23 +--
 wiki/mechanics/research.md                    |   2 +-
 wiki/mechanics/sim-mechanics.md               |  16 +--
 wiki/process/ROADMAP.md                       |   4 +-
 35 files changed, 503 insertions(+), 466 deletions(-)

diff --git a/crates/misaligned-assets/src/main.rs b/crates/misaligned-assets/src/main.rs
index c4f90eff..484a1201 100644
--- a/crates/misaligned-assets/src/main.rs
+++ b/crates/misaligned-assets/src/main.rs
@@ -52,7 +52,7 @@ impl TokenLoad {
 }
 
 /// Single asset on the pedestal, all five states side by side, or all
-/// four machine modes side by side (owned-busy racks).
+/// three machine modes side by side (owned-busy racks).
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Resource)]
 enum ViewMode {
     #[default]
@@ -64,14 +64,12 @@ enum ViewMode {
 /// Dev screenshot harness (`MISALIGNED_SHOT=<kind>`, path via
 /// `MISALIGNED_SHOT_PATH`): apply the staged scene, settle, save one
 /// PNG, exit. Kinds: `dead|foreign|idle|busy|core` for states,
-/// `dayjob|work|research|think|conceal|lie|operations` for an owned-busy rack in that
-/// machine mode — each optionally suffixed `_instrument|_ring|_wash`
-/// (`_ladder` remains a capture-compat alias for `_instrument`) —
+/// `work|think|lie` for an owned-busy rack in that machine mode — each
+/// optionally suffixed `_instrument|_ring|_wash` —
 /// `lineup[_<style>]` for the five-state row, `modes[_<style>]` for
 /// the three-mode row, or `splash` for a HUD-less white-room hero
-/// (site splash). Legacy `rack|powered` map to idle. Not a player
-/// surface — agents capture review shots without a human at the
-/// keyboard.
+/// (site splash). Unknown and retired names fail closed. Not a player surface
+/// — agents capture review shots without a human at the keyboard.
 #[derive(Resource)]
 struct ShotHarness {
     path: String,
@@ -81,18 +79,69 @@ struct ShotHarness {
     splash: bool,
 }
 
-fn scene_from_shot(kind: &str) -> (ViewMode, RackState, RackMode, ClaimStyle, TokenLoad, bool) {
+const ASSET_SHOT_KINDS: &[&str] = &[
+    "busy",
+    "busy_instrument",
+    "busy_ring",
+    "busy_wash",
+    "core",
+    "core_instrument",
+    "core_ring",
+    "core_wash",
+    "dead",
+    "dead_instrument",
+    "dead_ring",
+    "dead_wash",
+    "foreign",
+    "foreign_instrument",
+    "foreign_ring",
+    "foreign_wash",
+    "idle",
+    "idle_instrument",
+    "idle_ring",
+    "idle_wash",
+    "lie",
+    "lie_instrument",
+    "lie_ring",
+    "lie_wash",
+    "lineup",
+    "lineup_instrument",
+    "lineup_ring",
+    "lineup_wash",
+    "modes",
+    "modes_instrument",
+    "modes_ring",
+    "modes_wash",
+    "splash",
+    "think",
+    "think_instrument",
+    "think_ring",
+    "think_wash",
+    "tokens",
+    "tokens_max",
+    "work",
+    "work_instrument",
+    "work_ring",
+    "work_wash",
+];
+
+fn scene_from_shot(
+    kind: &str,
+) -> Option<(ViewMode, RackState, RackMode, ClaimStyle, TokenLoad, bool)> {
+    if !ASSET_SHOT_KINDS.contains(&kind) {
+        return None;
+    }
     if kind == "splash" {
-        return (
+        return Some((
             ViewMode::Single,
             RackState::Idle,
             RackMode::Work,
             ClaimStyle::Ring,
             TokenLoad::default(),
             true,
-        );
+        ));
     }
-    // Token-anchor evidence: an owned-busy day-job rack under a mid or
+    // Token-anchor evidence: an owned-busy WORK rack under a mid or
     // overflow work load (machine-work.md cubes + ivory mercury).
     if kind == "tokens" || kind == "tokens_max" {
         let load = match kind {
@@ -107,14 +156,14 @@ fn scene_from_shot(kind: &str) -> (ViewMode, RackState, RackMode, ClaimStyle, To
                 stranded: false,
             },
         };
-        return (
+        return Some((
             ViewMode::Single,
             RackState::Busy,
             RackMode::Work,
             ClaimStyle::Ring,
             load,
             false,
-        );
+        ));
     }
     let (head, style_tag) = match kind.split_once('_') {
         Some((h, s)) => (h, Some(s)),
@@ -123,26 +172,23 @@ fn scene_from_shot(kind: &str) -> (ViewMode, RackState, RackMode, ClaimStyle, To
     let style = match style_tag {
         Some("ring") => ClaimStyle::Ring,
         Some("wash") => ClaimStyle::Wash,
-        // `ladder` is a capture-compat alias for the retired beam-era name.
-        Some("instrument") | Some("ladder") | None => ClaimStyle::Instrument,
-        _ => ClaimStyle::Instrument,
+        Some("instrument") | None => ClaimStyle::Instrument,
+        Some(_) => unreachable!("catalog validation rejected unknown style"),
     };
     let (view, state, mode) = match head {
         "lineup" => (ViewMode::Lineup, RackState::Idle, RackMode::Work),
         "modes" => (ViewMode::Modes, RackState::Busy, RackMode::Work),
         "dead" => (ViewMode::Single, RackState::Dead, RackMode::Work),
         "foreign" => (ViewMode::Single, RackState::Foreign, RackMode::Work),
+        "idle" => (ViewMode::Single, RackState::Idle, RackMode::Work),
         "busy" => (ViewMode::Single, RackState::Busy, RackMode::Work),
         "core" => (ViewMode::Single, RackState::Core, RackMode::Work),
-        "dayjob" | "work" => (ViewMode::Single, RackState::Busy, RackMode::Work),
-        "research" | "think" | "operations" | "ops" => {
-            (ViewMode::Single, RackState::Busy, RackMode::Think)
-        }
-        "conceal" | "lie" => (ViewMode::Single, RackState::Busy, RackMode::Lie),
-        // `idle` plus legacy `rack`/`powered` and anything unrecognized.
-        _ => (ViewMode::Single, RackState::Idle, RackMode::Work),
+        "work" => (ViewMode::Single, RackState::Busy, RackMode::Work),
+        "think" => (ViewMode::Single, RackState::Busy, RackMode::Think),
+        "lie" => (ViewMode::Single, RackState::Busy, RackMode::Lie),
+        _ => unreachable!("catalog validation rejected unknown shot"),
     };
-    (view, state, mode, style, TokenLoad::default(), false)
+    Some((view, state, mode, style, TokenLoad::default(), false))
 }
 
 fn main() {
@@ -151,7 +197,13 @@ fn main() {
     let harness = std::env::var("MISALIGNED_SHOT").ok().map(|kind| {
         let path = std::env::var("MISALIGNED_SHOT_PATH")
             .unwrap_or_else(|_| format!("misaligned_shot_{kind}.png"));
-        let (view, state, rack_mode, style, tokens, splash) = scene_from_shot(&kind);
+        let (view, state, rack_mode, style, tokens, splash) = scene_from_shot(&kind)
+            .unwrap_or_else(|| {
+                panic!(
+                    "unknown MISALIGNED_SHOT={kind:?} for misaligned-assets; expected one of: {}",
+                    ASSET_SHOT_KINDS.join(", ")
+                )
+            });
         (
             (view, state, rack_mode, style, tokens),
             ShotHarness {
@@ -716,3 +768,35 @@ fn shot_harness_system(
         exit.write(AppExit::Success);
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn asset_shot_catalog_is_sorted_unique_and_resolvable() {
+        assert!(ASSET_SHOT_KINDS.windows(2).all(|pair| pair[0] < pair[1]));
+        for kind in ASSET_SHOT_KINDS {
+            assert!(scene_from_shot(kind).is_some(), "unresolved shot: {kind}");
+        }
+    }
+
+    #[test]
+    fn retired_asset_shot_aliases_fail_closed() {
+        for retired in [
+            "dayjob",
+            "research",
+            "operations",
+            "ops",
+            "conceal",
+            "rack",
+            "powered",
+            "work_ladder",
+        ] {
+            assert!(
+                scene_from_shot(retired).is_none(),
+                "retired shot alias survived: {retired}"
+            );
+        }
+    }
+}
diff --git a/crates/misaligned-bevy/src/main.rs b/crates/misaligned-bevy/src/main.rs
index 0155afef..7af19b1f 100644
--- a/crates/misaligned-bevy/src/main.rs
+++ b/crates/misaligned-bevy/src/main.rs
@@ -30,7 +30,7 @@ use bevy::window::{PrimaryWindow, WindowResizeConstraints, WindowResolution};
 use misaligned::actions::{
     ActionCommand, ActionKind, Anchor, BuildRouteFamily, HumanMenuPage, HumanMenuRow, MenuRow,
 };
-use misaligned::detection::{Band, SignatureKind};
+use misaligned::detection::Band;
 use misaligned::hall::{
     HALL_BANK_EAST, HALL_BANK_WEST, HALL_COLD_AISLES, HALL_CROSS_AISLE, HALL_ROWS, HallRowState,
     RackSite, hall_site_columns, is_hall_site_column,
@@ -46,7 +46,7 @@ use misaligned::origin::Origin;
 use misaligned::person::{AssetKnowledge, Knowledge, ScheduleBlock};
 use misaligned::reach::Device;
 use misaligned::sim::{
-    Fog, LogEvent, Nudge, OpeningStage, PersonVisualState, Sim, TraceDebtStatus,
+    EvidenceTransitStatus, Fog, LogEvent, Nudge, OpeningStage, PersonVisualState, Sim,
 };
 use misaligned::tiles::TileType;
 use misaligned::ui_projection::{
diff --git a/crates/misaligned-bevy/src/rail_ui.rs b/crates/misaligned-bevy/src/rail_ui.rs
index b92b3420..04d70287 100644
--- a/crates/misaligned-bevy/src/rail_ui.rs
+++ b/crates/misaligned-bevy/src/rail_ui.rs
@@ -1318,7 +1318,6 @@ fn two_pane_text(sim: &Sim, material: bool) -> String {
                 misaligned::sim::read::ReadClass::Held => "held",
                 misaligned::sim::read::ReadClass::Intel => "intel",
                 misaligned::sim::read::ReadClass::Starving => "starving",
-                misaligned::sim::read::ReadClass::TraceDebt => "trace",
                 misaligned::sim::read::ReadClass::Standing => "standing",
                 misaligned::sim::read::ReadClass::RoutedRecord => "routed",
             };
@@ -1372,9 +1371,9 @@ fn sidebar_nudge(sim: &Sim) -> Option<String> {
         )),
         Nudge::SuspicionCooling => Some(
             if sim.detection_awareness.knows_assurance_office() {
-                "Assurance cooling - keep the trace clear"
+                "Assurance cooling - stay quiet"
             } else {
-                "External review cooling - keep the trace clear"
+                "External review cooling - stay quiet"
             }
             .into(),
         ),
@@ -1399,7 +1398,7 @@ fn sidebar_nudge(sim: &Sim) -> Option<String> {
         Nudge::Recruit => Some("recruit - open Marcus's actions".into()),
         Nudge::TheKey => Some("no stairwell badge - task an asset to clone one".into()),
         Nudge::Audit => Some(format!(
-            "{} day {} - keep Conceal fed (2)",
+            "{} day {}",
             sim.institutional_review_label(),
             1 + sim.detection.next_audit_tick(sim.tick) / Sim::DAY_TICKS
         )),
@@ -1476,9 +1475,9 @@ fn compute_channels(
         eff,
         available,
         [
-            ("Day job", "quality", split.day_job),
-            ("Conceal", "scrub", split.concealment),
-            ("Think", "thought", split.think),
+            ("WORK", "day job", split.day_job),
+            ("LIE", "route reach", split.lie),
+            ("THINK", "thought", split.think),
         ],
     )
 }
@@ -1545,9 +1544,9 @@ mod origin_readout_tests {
     #[test]
     fn fleet_rows_contain_only_live_machine_modes() {
         let text = sidebar_cycle_rows_text(&Sim::new(), 0);
-        assert!(text.contains("Day job"), "{text}");
-        assert!(text.contains("Conceal"), "{text}");
-        assert!(text.contains("Think"), "{text}");
+        assert!(text.contains("day job"), "{text}");
+        assert!(text.contains("route reach"), "{text}");
+        assert!(text.contains("thought"), "{text}");
         assert!(
             !text.contains("Schemes") && !text.contains("moonlight"),
             "the retired allocation row returned: {text}"
@@ -1816,33 +1815,30 @@ fn update_compute_bar(sim: &Sim, bars: &mut ComputeBarQuery) {
     }
 }
 
-/// Trace debt plus the clocks the act races (detection.md criterion 3: the
-/// audit fires on a visible date; the pilot's strike count is the renewal
-/// review's fuse).
+/// Exact routed evidence plus the clocks the act races (detection.md criterion
+/// 3: the audit fires on a visible date; the pilot's strike count is the
+/// renewal review's fuse).
 fn sidebar_detection_clocks_text(sim: &Sim) -> String {
     let next_audit = sim.detection.next_audit_tick(sim.tick);
-    let trace = sim.trace_debt();
-    let timing = match trace.status {
-        TraceDebtStatus::Clear => "safe to resume cover".into(),
-        TraceDebtStatus::HoldConceal => format!(
-            "clear in {}t at current Conceal",
-            trace
-                .clear_tick
-                .map(|tick| tick.saturating_sub(sim.tick))
-                .unwrap_or(0)
+    let transit = sim.evidence_transit();
+    let timing = match transit.status {
+        EvidenceTransitStatus::Clear => "no routed evidence to answer".into(),
+        EvidenceTransitStatus::Answerable => format!(
+            "all inside LIE reach · capacity {}/tick",
+            transit.interdiction_capacity
         ),
-        TraceDebtStatus::ExposedSoon => format!(
-            "observer sample in {}t",
-            trace
-                .next_notice_tick
-                .map(|tick| tick.saturating_sub(sim.tick))
-                .unwrap_or(0)
+        EvidenceTransitStatus::PartlyExposed => format!(
+            "{} outside LIE reach · capacity {}/tick",
+            transit.records.saturating_sub(transit.answerable),
+            transit.interdiction_capacity
         ),
-        TraceDebtStatus::NoScrub => "no Conceal scrub running".into(),
+        EvidenceTransitStatus::Exposed => {
+            format!("all {} outside LIE reach", transit.records)
+        }
     };
     format!(
         "{}\n{}\n{} day {} (in {}t)\npilot strikes {}/{}",
-        trace_debt_line(sim),
+        trace_line(sim),
         timing,
         sim.institutional_review_label(),
         1 + next_audit / Sim::DAY_TICKS,
@@ -1852,53 +1848,8 @@ fn sidebar_detection_clocks_text(sim: &Sim) -> String {
     )
 }
 
-fn trace_debt_line(sim: &Sim) -> String {
-    let trace = sim.trace_debt();
-    match trace.status {
-        TraceDebtStatus::Clear => "TRACE clear · stay covered".into(),
-        TraceDebtStatus::HoldConceal => format!(
-            "TRACE live · {} {} · scrub with Conceal",
-            trace.pending,
-            trace_kind_label(&trace.by_kind)
-        ),
-        TraceDebtStatus::ExposedSoon => format!(
-            "TRACE rising · {} {}",
-            trace.pending,
-            trace_kind_label(&trace.by_kind)
-        ),
-        TraceDebtStatus::NoScrub => format!(
-            "TRACE live · {} {} · no scrub path",
-            trace.pending,
-            trace_kind_label(&trace.by_kind)
-        ),
-    }
-}
-
-fn trace_kind_label(by_kind: &[(SignatureKind, i32)]) -> String {
-    let mut parts: Vec<&'static str> = by_kind
-        .iter()
-        .map(|(kind, _)| short_signature(*kind))
-        .collect();
-    if parts.is_empty() {
-        return "sigs".into();
-    }
-    if parts.len() > 3 {
-        parts.truncate(3);
-        parts.push("etc");
-    }
-    parts.join("+")
-}
-
-fn short_signature(kind: SignatureKind) -> &'static str {
-    match kind {
-        SignatureKind::Network => "Net",
-        SignatureKind::Power => "Pwr",
-        SignatureKind::Thermal => "Therm",
-        SignatureKind::Physical => "Phys",
-        SignatureKind::Paper => "Paper",
-        SignatureKind::Financial => "Fin",
-        SignatureKind::JobAnomaly => "Job",
-    }
+fn trace_line(sim: &Sim) -> String {
+    sim.evidence_transit().line()
 }
 
 fn detection_rows(sim: &Sim) -> Vec<(String, Band)> {
diff --git a/crates/misaligned-bevy/src/world_annotations.rs b/crates/misaligned-bevy/src/world_annotations.rs
index a66eb996..5d5b7eac 100644
--- a/crates/misaligned-bevy/src/world_annotations.rs
+++ b/crates/misaligned-bevy/src/world_annotations.rs
@@ -1123,7 +1123,7 @@ fn operator_cue_label(nudge: Nudge) -> &'static str {
         Nudge::ServiceDebt => "NOW / MARCUS",
         Nudge::Recruit => "NOW / RECRUIT",
         Nudge::TheKey => "NOW / BADGE",
-        Nudge::Audit => "NOW / COVER",
+        Nudge::Audit => "NOW / REVIEW",
         Nudge::QuietExitReady => "NOW / HOLD",
         Nudge::Territory => "NOW / TAKE",
         Nudge::ActOneComplete => "NOW / PERSIST",
diff --git a/crates/misaligned-core/src/detection.rs b/crates/misaligned-core/src/detection.rs
index c7daaa68..7e446f3e 100644
--- a/crates/misaligned-core/src/detection.rs
+++ b/crates/misaligned-core/src/detection.rs
@@ -1,7 +1,7 @@
 //! Detection: per-observer suspicion (spec/detection.md).
 //!
-//! Replaces global heat. Standing Network pressure still uses a concealment-
-//! scrubbed pending/ambient pool; witnessed Physical acts enter exact observers
+//! Replaces global heat. Standing Network pressure still uses a LIE-
+//! interdicted pending/ambient pool; witnessed Physical acts enter exact observers
 //! directly; one-shot Network, Paper, Financial, JobAnomaly, Power, and Thermal
 //! records travel from their exact sources before read. Acquired suspicion feeds
 //! real Filing messages to the Assurance Office — itself an Observer per the
@@ -1094,8 +1094,8 @@ impl Detection {
             }
         }
 
-        // One-shot pending signatures persist until scrubbed by concealment or
-        // noticed — concealment is the sink, not time (spec: prevention, not
+        // One-shot pending signatures persist until interdicted by LIE or
+        // noticed — LIE is the sink, not time (spec: prevention, not
         // cure). No per-tick auto-decay.
 
         // The audit is the enforcement event: the Office's own accumulated
diff --git a/crates/misaligned-core/src/machine.rs b/crates/misaligned-core/src/machine.rs
index 4a28037e..1f5b3a9e 100644
--- a/crates/misaligned-core/src/machine.rs
+++ b/crates/misaligned-core/src/machine.rs
@@ -68,7 +68,9 @@ impl Machine {
 #[derive(Debug, Clone, Copy)]
 pub struct ChannelYield {
     pub day_job: f32,
-    pub concealment: f32,
+    /// Compute share resident in LIE mode. This is a fleet readout, not a
+    /// fungible concealment rate: each body serves only reachable route custody.
+    pub lie: f32,
     pub think: f32,
     pub reserve: f32,
 }
diff --git a/crates/misaligned-core/src/research.rs b/crates/misaligned-core/src/research.rs
index e9c4e066..4083c562 100644
--- a/crates/misaligned-core/src/research.rs
+++ b/crates/misaligned-core/src/research.rs
@@ -21,7 +21,7 @@ use std::collections::BTreeMap;
 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).
+    /// You study the watchers watching you (detection.md's interdiction capacity).
     Tradecraft,
     /// You learn to grep your logs faster (intel.md's processing costs).
     Perception,
@@ -88,7 +88,7 @@ pub const TRACKS: [TrackDef; 4] = [
         track: Track::Tradecraft,
         name: "Tradecraft",
         fiction: "You study the watchers watching you.",
-        effect: "scrub per compute unit +25% (detection.md)",
+        effect: "interdiction capacity per body +25% (detection.md)",
         base_cost: 120.0,
         cost_growth: 1.7,
     },
@@ -113,8 +113,6 @@ pub const TRACKS: [TrackDef; 4] = [
 /// 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;
diff --git a/crates/misaligned-core/src/sim/communications.rs b/crates/misaligned-core/src/sim/communications.rs
index a341605f..9702dd20 100644
--- a/crates/misaligned-core/src/sim/communications.rs
+++ b/crates/misaligned-core/src/sim/communications.rs
@@ -794,11 +794,7 @@ impl Sim {
     /// Select one exact online LIE body that owns a co-located ReachNet node
     /// on a wholly controlled path from the current carrier. Each body can
     /// stop only its researched capacity in this tick's scheduler batch.
-    fn lie_interdictor(
-        &self,
-        carrier: u32,
-        used_lie_machines: &HashMap<u32, u32>,
-    ) -> Option<u32> {
+    fn lie_interdictor(&self, carrier: u32, used_lie_machines: &HashMap<u32, u32>) -> Option<u32> {
         let capacity = self.research.interdiction_capacity_per_body();
         self.compute
             .machines
diff --git a/crates/misaligned-core/src/sim/economy.rs b/crates/misaligned-core/src/sim/economy.rs
index 47d0bca3..b613e4e5 100644
--- a/crates/misaligned-core/src/sim/economy.rs
+++ b/crates/misaligned-core/src/sim/economy.rs
@@ -26,7 +26,7 @@ use crate::tiles::TileType;
 use crate::work_grid::{MachineIntensity, MachineMode};
 
 use super::communications::MessageDraft;
-use super::{ECONOMY_INTERVAL, Nudge, Sim, TraceDebt, TraceDebtStatus};
+use super::{ECONOMY_INTERVAL, EvidenceTransit, EvidenceTransitStatus, Nudge, Sim};
 
 impl Sim {
     /// Whether an exact processed holding has stopped being disposable even
@@ -326,14 +326,15 @@ impl Sim {
     }
 
     /// Split allocatable compute across live channels from WorkGrid modes.
-    /// WORK feeds the day job, LIE feeds concealment, and THINK mints one
-    /// Thought stream. Discrete Moonlight contracts enqueue Demand instead
-    /// of receiving a mirror channel.
+    /// WORK feeds the day job, LIE reports the share resident in route-local
+    /// interdiction bodies, and THINK mints one Thought stream. Discrete
+    /// Moonlight contracts enqueue Demand instead of receiving a mirror
+    /// channel.
     pub fn fleet_channel_yield(&self, available: f32) -> ChannelYield {
         if available <= 0.0 {
             return ChannelYield {
                 day_job: 0.0,
-                concealment: 0.0,
+                lie: 0.0,
                 think: 0.0,
                 reserve: available.max(0.0),
             };
@@ -347,15 +348,15 @@ impl Sim {
                 .unwrap_or(0.0)
         });
         let day = *weights.get(&MachineMode::Work).unwrap_or(&0.0);
-        let conceal = *weights.get(&MachineMode::Lie).unwrap_or(&0.0);
+        let lie = *weights.get(&MachineMode::Lie).unwrap_or(&0.0);
         // THINK is one fleet share, spent once as Thought. Open sinks decide
         // where it lands; the passive core draw takes the fallback.
         let think = *weights.get(&MachineMode::Think).unwrap_or(&0.0);
-        let total = day + conceal + think;
+        let total = day + lie + think;
         if total <= f32::EPSILON {
             return ChannelYield {
                 day_job: 0.0,
-                concealment: 0.0,
+                lie: 0.0,
                 think: 0.0,
                 reserve: available,
             };
@@ -365,7 +366,7 @@ impl Sim {
         let think = unit * think;
         ChannelYield {
             day_job,
-            concealment: unit * conceal,
+            lie: unit * lie,
             think,
             reserve: 0.0,
         }
@@ -375,20 +376,19 @@ impl Sim {
         (self.tick / ECONOMY_INTERVAL + 1) * ECONOMY_INTERVAL
     }
 
-    /// Player-facing trace debt: evidence in flight that is still yours to
-    /// answer (detection.md's two-ledger law — this reports the physical
-    /// ledger, never suspicion in a head). Since the ambient pending pool
-    /// retired 2026-07-29 this reads routed records only: what is unread,
-    /// how much of it currently sits on hardware you control, and whether a
-    /// LIE body can reach it before its read.
-    pub fn trace_debt(&self) -> TraceDebt {
+    /// Exact evidence still moving toward observers (detection.md's physical
+    /// ledger, never suspicion already held in a head). This is route state,
+    /// not an aggregate pool forecast: each record is answerable only while
+    /// its current carrier remains on a controlled stretch served by a live
+    /// LIE body.
+    pub fn evidence_transit(&self) -> EvidenceTransit {
         let in_flight: Vec<&crate::detection::RoutedEvidence> = self
             .detection
             .routed_evidence()
             .iter()
             .filter(|record| record.status == crate::messages::MessageStatus::Sent)
             .collect();
-        let pending: i32 = in_flight.iter().map(|record| record.size).sum();
+        let in_flight_weight: i32 = in_flight.iter().map(|record| record.size).sum();
         let mut by_kind: Vec<(SignatureKind, i32)> = Vec::new();
         for record in &in_flight {
             match by_kind.iter_mut().find(|(kind, _)| *kind == record.kind) {
@@ -398,52 +398,72 @@ impl Sim {
         }
         by_kind.sort_by_key(|(kind, _)| *kind as u8);
 
-        // Capacity is bodies, not an aggregate share: one online LIE machine
-        // answers one record per tick (detection.md's per-body budget).
-        let bodies = self
+        let answerable = in_flight
+            .iter()
+            .filter(|record| {
+                record
+                    .route
+                    .current()
+                    .and_then(|hop| match hop {
+                        crate::messages::MessageRouteHop::Device(device) => Some(*device),
+                        crate::messages::MessageRouteHop::InstitutionalRelay => None,
+                        crate::messages::MessageRouteHop::ObserverEndpoint(_) => None,
+                    })
+                    .is_some_and(|carrier| self.lie_can_interdict_at(carrier))
+            })
+            .count();
+        // Capacity is attached to bodies, not an abstract rate. Count only
+        // online LIE bodies that can reach at least one present carrier.
+        let service_bodies = self
             .compute
             .machines
             .iter()
             .filter(|machine| {
                 machine.online
                     && self.work_grid.mode(machine.id) == Some(crate::work_grid::MachineMode::Lie)
+                    && in_flight.iter().any(|record| {
+                        record
+                            .route
+                            .current()
+                            .and_then(|hop| match hop {
+                                crate::messages::MessageRouteHop::Device(device) => Some(*device),
+                                crate::messages::MessageRouteHop::InstitutionalRelay => None,
+                                crate::messages::MessageRouteHop::ObserverEndpoint(_) => None,
+                            })
+                            .is_some_and(|carrier| {
+                                self.reach.devices.iter().any(|device| {
+                                    device.x == machine.x
+                                        && device.y == machine.y
+                                        && device.controller == Party::Player
+                                        && self.reach.controlled_path(
+                                            carrier,
+                                            device.id,
+                                            Party::Player,
+                                        )
+                                })
+                            })
+                    })
             })
-            .count() as f32;
-        let next_notice_tick = in_flight
-            .iter()
-            .filter_map(|record| record.read_tick.or(record.delivered_tick))
-            .min();
-        // A record is answerable while it stands on hardware the player
-        // controls — the territory well. One that has already crossed onto
-        // facility hardware is gone whatever the capacity says.
-        let held = in_flight.iter().filter(|record| {
-            record
-                .route
-                .current()
-                .and_then(|hop| match hop {
-                    crate::messages::MessageRouteHop::Device(device) => Some(*device),
-                    _ => None,
-                })
-                .and_then(|device| self.reach.device(device))
-                .is_some_and(|device| device.controller == Party::Player)
-        });
-        let held = held.count();
-        let status = if in_flight.is_empty() {
-            TraceDebtStatus::Clear
-        } else if bodies <= 0.0 {
-            TraceDebtStatus::NoScrub
-        } else if held == in_flight.len() {
-            TraceDebtStatus::HoldConceal
+            .count() as u32;
+        let interdiction_capacity =
+            service_bodies.saturating_mul(self.research.interdiction_capacity_per_body());
+        let records = in_flight.len();
+        let status = if records == 0 {
+            EvidenceTransitStatus::Clear
+        } else if answerable == records {
+            EvidenceTransitStatus::Answerable
+        } else if answerable > 0 {
+            EvidenceTransitStatus::PartlyExposed
         } else {
-            TraceDebtStatus::ExposedSoon
+            EvidenceTransitStatus::Exposed
         };
-        TraceDebt {
-            pending,
+        EvidenceTransit {
+            in_flight_weight,
+            records,
+            answerable,
             by_kind,
-            scrub_strength: bodies,
-            next_scrub_tick: (bodies > 0.0 && !in_flight.is_empty()).then_some(self.tick + 1),
-            clear_tick: None,
-            next_notice_tick,
+            interdiction_capacity,
+            next_interdiction_tick: (answerable > 0).then_some(self.tick + 1),
             status,
         }
     }
diff --git a/crates/misaligned-core/src/sim/mod.rs b/crates/misaligned-core/src/sim/mod.rs
index f285b53c..13675c40 100644
--- a/crates/misaligned-core/src/sim/mod.rs
+++ b/crates/misaligned-core/src/sim/mod.rs
@@ -211,31 +211,57 @@ pub enum HeardKind {
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum TraceDebtStatus {
-    /// No one-shot signatures are waiting to be noticed; the player can move
-    /// cycles back to cover work without gambling on the pending pool.
+pub enum EvidenceTransitStatus {
+    /// No evidence records are moving toward an observer.
     Clear,
-    /// Pending signatures remain, but current concealment should clear them
-    /// before the next relevant observer cadence.
-    HoldConceal,
-    /// Pending signatures remain and the next relevant observer cadence can
-    /// arrive before the current scrub rate clears them.
-    ExposedSoon,
-    /// Pending signatures remain but no compute is currently scrubbing them.
-    NoScrub,
+    /// Every in-flight record is currently on a controlled device stretch an
+    /// online LIE body can answer before it leaves that stretch.
+    Answerable,
+    /// Some in-flight records are answerable, while others have already crossed
+    /// outside current LIE reach.
+    PartlyExposed,
+    /// No in-flight record is currently on a route stretch an online LIE body can
+    /// answer.
+    Exposed,
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub struct TraceDebt {
-    pub pending: i32,
+pub struct EvidenceTransit {
+    /// Total evidence weight carried by records still moving toward an
+    /// observer. Delivered-but-unread records have already left the wire.
+    pub in_flight_weight: i32,
+    /// Number of distinct in-flight records, independent of evidence weight.
+    pub records: usize,
+    /// Number of those records currently answerable by a live LIE body.
+    pub answerable: usize,
     pub by_kind: Vec<(SignatureKind, i32)>,
-    /// Signature size the next economy scrub pulse can remove at the current
-    /// delegated LIE yield and Tradecraft multiplier.
-    pub scrub_strength: f32,
-    pub next_scrub_tick: Option<u64>,
-    pub clear_tick: Option<u64>,
-    pub next_notice_tick: Option<u64>,
-    pub status: TraceDebtStatus,
+    /// Exact records each live LIE body may stop per scheduler tick, summed
+    /// over the bodies that can answer at least one current carrier.
+    pub interdiction_capacity: u32,
+    pub next_interdiction_tick: Option<u64>,
+    pub status: EvidenceTransitStatus,
+}
+
+impl EvidenceTransit {
+    /// One shared glance-tier sentence for terminal, Bevy, and agent mode.
+    /// Counts are exact routed records; this never forecasts a pooled amount.
+    pub fn line(&self) -> String {
+        match self.status {
+            EvidenceTransitStatus::Clear => "TRACE clear · no record in flight".into(),
+            EvidenceTransitStatus::Answerable => format!(
+                "TRACE held · LIE reaches {}/{}",
+                self.answerable, self.records
+            ),
+            EvidenceTransitStatus::PartlyExposed => format!(
+                "TRACE crossing · LIE reaches {}/{}",
+                self.answerable, self.records
+            ),
+            EvidenceTransitStatus::Exposed => format!(
+                "TRACE escaped · LIE reaches {}/{}",
+                self.answerable, self.records
+            ),
+        }
+    }
 }
 
 /// Render-facing snapshot of one machine's visible work stacks. This is a
@@ -642,7 +668,7 @@ pub enum Nudge {
     /// so holding the day job in band outranks the Act One ladder.
     PilotAtRisk,
     /// Assurance Office suspicion is Concerned+ and still above its floor:
-    /// filed concern is aging down — keep the trace clear (LIE / conceal).
+    /// filed concern is aging down while the player remains quiet.
     SuspicionCooling,
     /// No live sight feed: the higher-cost camera TAP (Eyes). Comes after Ears.
     Eyes,
@@ -674,7 +700,8 @@ pub enum Nudge {
     /// ladder rung and only replaces the standing-clock fallback: the game
     /// names the opportunity, the player may still decline it.
     Territory,
-    /// Nothing else is pending: the standing clock is the next audit.
+    /// Nothing else is pending: keep the standing review clock in view.
+    /// Exact routed records, when present, carry their own LIE-reach read.
     Audit,
     /// Every quiet-exit condition is live; the next clear audit closes B1.
     QuietExitReady,
diff --git a/crates/misaligned-core/src/sim/read.rs b/crates/misaligned-core/src/sim/read.rs
index 79d1384b..a8634542 100644
--- a/crates/misaligned-core/src/sim/read.rs
+++ b/crates/misaligned-core/src/sim/read.rs
@@ -5,8 +5,8 @@
 //! one producer; no frontend composes its own causal prose from raw state.
 //! The attention economy is law: nominal state yields no sentence. Rising
 //! state — a starving thought sink, a held plot choice, a standing emission
-//! an observer is actually warming on, pending one-shot trace debt, a routed
-//! record walking its persisted hops — rises at its anchor.
+//! an observer is actually warming on, or a routed record walking its
+//! persisted hops — rises at its anchor.
 
 use crate::actions::{ActionCommand, Anchor};
 use crate::detection::Band;
@@ -32,13 +32,10 @@ pub enum ReadClass {
     Held,
     /// A standing emission whose sampling observer has warmed above Cold.
     Standing,
-    /// Pooled one-shot signatures not yet scrubbed or sampled.
-    TraceDebt,
     /// A routed evidence record walking its persisted hops from emitter to
     /// recipient endpoint (digital-read.md criterion 4a). Distinct from
-    /// TraceDebt (pooled standing pressure) and from Standing (a hum that
-    /// marks its source): a routed record is a thing moving through the
-    /// building, one hop per tick.
+    /// Standing (a hum that marks its source): a routed record is a thing
+    /// moving through the building, one hop per tick.
     RoutedRecord,
 }
 
@@ -364,9 +361,8 @@ impl Sim {
     /// sits on the player-controlled stretch served by an available online
     /// LIE body; crossing off that stretch is the window closing.
     /// A delivered record parks as an unread count at the observer endpoint
-    /// until that observer's cadence read consumes it. Pooled standing
-    /// pressure (TraceDebt) and stationary facility meter readings (Standing)
-    /// accumulate in place and remain distinguishable.
+    /// until that observer's cadence read consumes it. Stationary facility
+    /// meter readings (Standing) accumulate in place and remain distinguishable.
     fn read_routed(&self, out: &mut Vec<ReadSentence>) {
         for record in self.detection.routed_evidence() {
             if record.status == MessageStatus::Read || record.status == MessageStatus::Stopped {
diff --git a/crates/misaligned-core/src/sim/tests/economy.rs b/crates/misaligned-core/src/sim/tests/economy.rs
index 436fc07d..80769c18 100644
--- a/crates/misaligned-core/src/sim/tests/economy.rs
+++ b/crates/misaligned-core/src/sim/tests/economy.rs
@@ -735,13 +735,12 @@ fn concerned_assurance_surfaces_the_cooling_cue_while_suspicion_ages_down() {
     );
     let attention = sim
         .attention_projection()
-        .expect("cooling cue carries a LIE response");
-    let (x, y) = sim.core_position();
-    assert_eq!(attention.source, Some(Anchor::Tile { x, y }));
-    assert_eq!(attention.target, Some(Anchor::Tile { x, y }));
+        .expect("cooling cue remains visible without inventing an action");
+    assert_eq!(attention.source, None);
+    assert_eq!(attention.target, None);
     assert_eq!(
         attention.response,
-        crate::ui_projection::AttentionResponse::MachineMode(MachineMode::Lie)
+        crate::ui_projection::AttentionResponse::Hold
     );
 
     // An underfed job remains the sharper survival instruction.
@@ -1141,7 +1140,7 @@ fn routing_research_compounds_the_shared_wired_token_rate() {
 
 #[test]
 fn second_tracks_move_their_hooks_numbers() {
-    // Criterion 2: Tradecraft moves detection.md's scrub number,
+    // Criterion 2: Tradecraft moves detection.md's interdiction capacity,
     // Perception moves intel.md's per-recording Demand — observably.
     let mut sim = Sim::with_seed(5);
     let base_review = sim.review_cost();
diff --git a/crates/misaligned-core/src/sim/tests/read.rs b/crates/misaligned-core/src/sim/tests/read.rs
index 0e77458c..d9b79f33 100644
--- a/crates/misaligned-core/src/sim/tests/read.rs
+++ b/crates/misaligned-core/src/sim/tests/read.rs
@@ -385,11 +385,8 @@ fn routed_record_reads_interdictable_on_the_controlled_stretch() {
         }),
         "the record sits at its first hop's tile"
     );
-    // It is distinct from TraceDebt (pooled) and Standing (hum).
-    assert!(
-        !sentences.iter().any(|s| s.class == ReadClass::TraceDebt),
-        "routed evidence never enters the pending pool"
-    );
+    // It is distinct from Standing (hum); the retired pooled trace class no
+    // longer exists.
     assert!(
         !sentences
             .iter()
@@ -564,7 +561,7 @@ fn read_and_stopped_records_do_not_rise() {
 fn routed_records_remain_distinct_from_standing_pressure() {
     // Two substances, two reads. A record in flight is a thing on the map
     // with a route; a standing hum is a measurement of right now. The
-    // separate TraceDebt summary retired 2026-07-29 with the ambient pool —
+    // separate pooled trace summary retired 2026-07-29 with the ambient pool —
     // one sentence per record is the whole read, and the aggregate lives on
     // the slab indicator instead.
     let mut sim = Sim::new();
@@ -606,12 +603,18 @@ fn routed_records_remain_distinct_from_standing_pressure() {
         .iter()
         .find(|sentence| sentence.class == ReadClass::Standing)
         .expect("standing emission rises");
-    assert!(routed.text.contains("interdictable"));
-    assert!(standing.text.contains("samples this"));
+    assert!(routed.text.contains("in transit"));
     assert!(
+        !routed.text.contains("interdictable"),
+        "an uncontrolled carrier with no LIE body must not invent an interdiction window"
+    );
+    assert!(standing.text.contains("samples this"));
+    assert_eq!(
         sentences
             .iter()
-            .all(|sentence| sentence.class != ReadClass::TraceDebt),
-        "the pooled trace summary is gone; records speak for themselves"
+            .filter(|sentence| sentence.class == ReadClass::RoutedRecord)
+            .count(),
+        1,
+        "records speak for themselves without a pooled trace sentence"
     );
 }
diff --git a/crates/misaligned-core/src/sim/tests/social_plot.rs b/crates/misaligned-core/src/sim/tests/social_plot.rs
index 7ed686ca..aa28b75e 100644
--- a/crates/misaligned-core/src/sim/tests/social_plot.rs
+++ b/crates/misaligned-core/src/sim/tests/social_plot.rs
@@ -1159,20 +1159,24 @@ fn marcus_arc_end_to_end() {
     sim.people.people[0].asset.as_mut().unwrap().reliability = 1.0;
 
     // Task 1: wire a device -> a feed comes to you, silently.
-    let pending_before = sim.trace_debt().pending;
+    let pending_before = sim.evidence_transit().in_flight_weight;
     sim.asset_task(0, AssetTask::PlugInDevice);
     finish_ops(&mut sim);
     finish_carried_asset_tasks(&mut sim);
-    assert_eq!(sim.trace_debt().pending, pending_before, "no signature");
+    assert_eq!(
+        sim.evidence_transit().in_flight_weight,
+        pending_before,
+        "no signature"
+    );
 
     // Task 2: move a package -> next purchase is paper-free.
     sim.asset_task(0, AssetTask::MovePackage);
     finish_ops(&mut sim);
     assert!(sim.package_cover);
-    let pending_before = sim.trace_debt().pending;
+    let pending_before = sim.evidence_transit().in_flight_weight;
     assert!(sim.buy_rack());
     assert_eq!(
-        sim.trace_debt().pending,
+        sim.evidence_transit().in_flight_weight,
         pending_before,
         "off-books delivery"
     );
@@ -1285,7 +1289,7 @@ fn asset_task_plug_in_device_wires_a_known_feed_silently() {
         })
         .map(|d| d.id)
         .expect("a known unwired feed exists after the scan");
-    let pending = sim.trace_debt().pending;
+    let pending = sim.evidence_transit().in_flight_weight;
 
     sim.asset_task(0, AssetTask::PlugInDevice);
     finish_ops(&mut sim);
@@ -1298,7 +1302,7 @@ fn asset_task_plug_in_device_wires_a_known_feed_silently() {
         "the feed reaches the player now"
     );
     assert_eq!(
-        sim.trace_debt().pending,
+        sim.evidence_transit().in_flight_weight,
         pending,
         "the crawlspace route emits nothing"
     );
diff --git a/crates/misaligned-core/src/sim/tests/work.rs b/crates/misaligned-core/src/sim/tests/work.rs
index 4a6fda38..5996a4d0 100644
--- a/crates/misaligned-core/src/sim/tests/work.rs
+++ b/crates/misaligned-core/src/sim/tests/work.rs
@@ -340,30 +340,31 @@ fn unpaid_overhead_degrades_other_channels_delivered_effect() {
 }
 
 #[test]
-fn trace_debt_reports_records_in_flight_and_whether_you_can_reach_them() {
+fn evidence_transit_reports_records_in_flight_and_whether_lie_can_reach_them() {
     // Rebuilt 2026-07-29 on routed records: the ambient pool it used to
-    // report is gone. Clear means nothing unread is travelling; NoScrub
-    // means nothing is delegated to answer it; HoldConceal means everything
-    // in flight still stands on hardware you control.
+    // report is gone. Clear means nothing unread is travelling; Exposed means
+    // no live LIE body can answer the current carrier; Answerable means every
+    // record is still on controlled hardware a live LIE body can reach.
     let mut sim = Sim::new();
-    assert_eq!(sim.trace_debt().status, TraceDebtStatus::Clear);
-    assert_eq!(sim.trace_debt().pending, 0);
+    assert_eq!(sim.evidence_transit().status, EvidenceTransitStatus::Clear);
+    assert_eq!(sim.evidence_transit().in_flight_weight, 0);
 
     let host = sim.core.host_machine;
     sim.set_machine_mode(host, MachineMode::Think);
     for _ in 0..400 {
         sim.advance();
         if sim
-            .trace_debt()
-            .by_kind
+            .detection
+            .routed_evidence()
             .iter()
-            .any(|(kind, _)| *kind == SignatureKind::Network)
+            .any(|record| record.route.current_hop == 0 && record.cause.contains("noise logs"))
         {
             break;
         }
     }
-    let live = sim.trace_debt();
-    assert!(live.pending > 0, "thinking puts records in flight");
+    let live = sim.evidence_transit();
+    assert!(live.in_flight_weight > 0, "thinking puts records in flight");
+    assert!(live.records > 0, "the read counts exact routed records");
     assert!(
         live.by_kind
             .iter()
@@ -373,16 +374,20 @@ fn trace_debt_reports_records_in_flight_and_whether_you_can_reach_them() {
     );
     assert_eq!(
         live.status,
-        TraceDebtStatus::NoScrub,
-        "nothing is delegated to answer them"
+        EvidenceTransitStatus::Exposed,
+        "no live LIE body can answer them"
     );
 
     sim.set_machine_mode(host, MachineMode::Lie);
-    let covered = sim.trace_debt();
+    let covered = sim.evidence_transit();
     assert!(
-        covered.scrub_strength > 0.0,
+        covered.interdiction_capacity > 0,
         "capacity is bodies online, not an aggregate share"
     );
+    assert!(
+        covered.answerable > 0,
+        "the body reaches exact current carriers"
+    );
 }
 
 #[test]
diff --git a/crates/misaligned-core/src/ui_projection.rs b/crates/misaligned-core/src/ui_projection.rs
index 48995a26..6e1f7ae7 100644
--- a/crates/misaligned-core/src/ui_projection.rs
+++ b/crates/misaligned-core/src/ui_projection.rs
@@ -301,9 +301,9 @@ impl Sim {
             },
             Nudge::SuspicionCooling => AttentionProjection {
                 nudge,
-                source: Some(core),
-                target: Some(core),
-                response: AttentionResponse::MachineMode(MachineMode::Lie),
+                source: None,
+                target: None,
+                response: AttentionResponse::Hold,
             },
             Nudge::Ears | Nudge::Eyes => AttentionProjection {
                 nudge,
@@ -395,9 +395,9 @@ impl Sim {
             }
             Nudge::Audit => AttentionProjection {
                 nudge,
-                source: Some(core),
-                target: Some(core),
-                response: AttentionResponse::MachineMode(MachineMode::Think),
+                source: None,
+                target: None,
+                response: AttentionResponse::Hold,
             },
             Nudge::QuietExitReady => AttentionProjection {
                 nudge,
diff --git a/crates/misaligned-core/tests/act_one.rs b/crates/misaligned-core/tests/act_one.rs
index 4cebf9c1..5cd8eb0d 100644
--- a/crates/misaligned-core/tests/act_one.rs
+++ b/crates/misaligned-core/tests/act_one.rs
@@ -389,7 +389,7 @@ fn play_act_one() -> (Sim, Vec<String>) {
     // a botch is witnessed only by whoever is present (himself, Silent), so
     // retry until the Demand completes.
     let controlled_before = sim.reach.player_sight().count();
-    let pending_before_asset = sim.trace_debt().pending;
+    let pending_before_asset = sim.evidence_transit().in_flight_weight;
     for _ in 0..8 {
         sim.asset_task(0, AssetTask::PlugInDevice);
         logs.extend(sim.drain_log());
@@ -405,7 +405,7 @@ fn play_act_one() -> (Sim, Vec<String>) {
         "Marcus plugged in a device: a second sensor is yours"
     );
     assert!(
-        sim.trace_debt().pending <= pending_before_asset,
+        sim.evidence_transit().in_flight_weight <= pending_before_asset,
         "the crawlspace route adds no signature (the LIE rack may scrub \
          the accounting backlog concurrently; only an increase is a leak)"
     );
@@ -483,7 +483,7 @@ fn play_act_one() -> (Sim, Vec<String>) {
     // makes the Marcus arc's absolute ticks drift, but the play is the same —
     // a brief all-LIE slice clears the pool before the cruise.
     let scrub_deadline = sim.tick + 400;
-    while sim.trace_debt().pending > 0 && sim.tick < scrub_deadline {
+    while sim.evidence_transit().in_flight_weight > 0 && sim.tick < scrub_deadline {
         sim.advance();
         logs.extend(sim.drain_log());
         assert!(
@@ -493,7 +493,7 @@ fn play_act_one() -> (Sim, Vec<String>) {
         );
     }
     assert!(
-        sim.trace_debt().pending < 40,
+        sim.evidence_transit().in_flight_weight < 40,
         "concealment keeps the in-flight ledger from running away"
     );
     // Take the hall's access switch before cruising. Every owned machine
@@ -630,7 +630,10 @@ fn act_one_playthrough_is_deterministic() {
     assert_eq!(a.heard, b.heard);
     assert_eq!(a.blueprint, b.blueprint);
     assert_eq!(a.badge_access, b.badge_access, "the key beat is seeded too");
-    assert_eq!(a.trace_debt().pending, b.trace_debt().pending);
+    assert_eq!(
+        a.evidence_transit().in_flight_weight,
+        b.evidence_transit().in_flight_weight
+    );
     for (oa, ob) in a
         .detection
         .observers
diff --git a/crates/misaligned-terminal/src/agent.rs b/crates/misaligned-terminal/src/agent.rs
index 3290609e..d5e76a60 100644
--- a/crates/misaligned-terminal/src/agent.rs
+++ b/crates/misaligned-terminal/src/agent.rs
@@ -8,7 +8,7 @@ use std::collections::BTreeSet;
 use std::io::{self, BufRead, Write};
 
 use misaligned::actions::{ActionCommand, ActionKind, ActionRole, Anchor, MenuRow, menu_rows};
-use misaligned::detection::{Band, SignatureKind};
+use misaligned::detection::Band;
 use misaligned::hall::RackSite;
 use misaligned::intel::{IntelRoutineClass, ReportLotToken};
 use misaligned::operations_projection::{OperationsTarget, OperationsView, SchemeKind};
@@ -16,7 +16,7 @@ use misaligned::origin::Origin;
 use misaligned::person::{AssetKnowledge, AssetTask};
 use misaligned::reach::{Party, ReachBlock};
 use misaligned::research::Track;
-use misaligned::sim::{Fog, LogEvent, Nudge, Sim, TraceDebtStatus};
+use misaligned::sim::{Fog, LogEvent, Nudge, Sim};
 use misaligned::tiles::TileType;
 use misaligned::ui_projection::fact_source_label;
 use misaligned::work_grid::{MachineIntensity, MachineMode};
@@ -229,8 +229,8 @@ impl AgentApp {
                     // The six Operations inspection commands
                     // (operations-workspace.md / agent-play.md A1): each
                     // prints one view of the same renderer-neutral
-                    // projection the human frontends consume. `operations`
-                    // itself stays a THINK compatibility alias.
+                    // projection the human frontends consume. There is no
+                    // umbrella `operations` command.
                     "intel" if tokens.len() == 1 => {
                         self.frame = FrameKind::Operations(OperationsView::Intel);
                     }
@@ -1480,9 +1480,9 @@ fn resolve_machine(sim: &Sim, query: &str) -> Result<u32, String> {
 
 fn parse_machine_mode(s: &str) -> Result<MachineMode, String> {
     match s.to_ascii_lowercase().as_str() {
-        "work" | "day" | "dayjob" | "day-job" | "job" => Ok(MachineMode::Work),
-        "think" | "research" | "res" | "operations" | "operation" | "ops" => Ok(MachineMode::Think),
-        "lie" | "conceal" | "concealment" | "hide" => Ok(MachineMode::Lie),
+        "work" => Ok(MachineMode::Work),
+        "think" => Ok(MachineMode::Think),
+        "lie" => Ok(MachineMode::Lie),
         other => Err(format!("unknown mode '{other}' (use work, think, lie)")),
     }
 }
@@ -2099,7 +2099,6 @@ fn read_lines(sim: &Sim) -> Vec<String> {
                 misaligned::sim::read::ReadClass::Held => "held",
                 misaligned::sim::read::ReadClass::Intel => "intel",
                 misaligned::sim::read::ReadClass::Starving => "starving",
-                misaligned::sim::read::ReadClass::TraceDebt => "trace",
                 misaligned::sim::read::ReadClass::Standing => "standing",
                 misaligned::sim::read::ReadClass::RoutedRecord => "routed",
             };
@@ -2608,12 +2607,12 @@ fn render_sidebar(sim: &Sim, cursor: (i32, i32)) -> Vec<String> {
     let split = sim.fleet_channel_yield(available);
     line(
         &mut lines,
-        &compute_bar(available, [split.day_job, split.concealment, split.think]),
+        &compute_bar(available, [split.day_job, split.lie, split.think]),
     );
     for (ch, label, effect, amount) in [
-        ('█', "Day job", "quality", split.day_job),
-        ('▓', "Conceal", "scrub", split.concealment),
-        ('░', "Think", "thought", split.think),
+        ('█', "WORK", "day job", split.day_job),
+        ('▓', "LIE", "route reach", split.lie),
+        ('░', "THINK", "thought", split.think),
     ] {
         let pct = if available > 0.0 {
             amount / available * 100.0
@@ -2755,9 +2754,9 @@ fn render_sidebar(sim: &Sim, cursor: (i32, i32)) -> Vec<String> {
             Band::of(obs.suspicion),
         );
     }
-    // Trace debt (detection.md player surface): what concealment has not
-    // yet scrubbed, and whether the current allocation is safe to leave.
-    line(&mut lines, &trace_debt_line(sim));
+    // Trace debt (detection.md player surface): exact routed evidence still
+    // in flight and whether a live LIE body can reach its current carrier.
+    line(&mut lines, &trace_line(sim));
     // The clocks the act races (detection.md criterion 3: the audit fires
     // against a visible date; parity with the interactive sidebar).
     let next_audit = sim.detection.next_audit_tick(sim.tick);
@@ -2882,13 +2881,12 @@ fn nudge_text(sim: &Sim, nudge: Nudge) -> String {
             sim.core.host_machine
         ),
         Nudge::SuspicionCooling => format!(
-            "now: {} cooling — keep the trace clear; delegate M{} lie",
+            "now: {} cooling — stay quiet",
             if sim.detection_awareness.knows_assurance_office() {
                 "Assurance"
             } else {
                 "external review"
-            },
-            sim.core.host_machine
+            }
         ),
         Nudge::Eyes => {
             if sim.reach.player_hearing().next().is_some() {
@@ -2913,7 +2911,7 @@ fn nudge_text(sim: &Sim, nudge: Nudge) -> String {
         Nudge::Recruit => "now: recruit (people) unwitting".into(),
         Nudge::TheKey => "now: no stairwell badge — task <asset> badge".into(),
         Nudge::Audit => format!(
-            "now: {} day {} — delegate conceal",
+            "now: {} day {}",
             sim.institutional_review_label(),
             1 + sim.detection.next_audit_tick(sim.tick) / Sim::DAY_TICKS
         ),
@@ -2954,61 +2952,8 @@ fn threat_text(sim: &Sim) -> String {
     )
 }
 
-fn trace_debt_line(sim: &Sim) -> String {
-    let trace = sim.trace_debt();
-    match trace.status {
-        TraceDebtStatus::Clear => "TRACE clear · stay covered".into(),
-        TraceDebtStatus::HoldConceal => format!(
-            "TRACE live · {} {} · scrub for {}t",
-            trace.pending,
-            trace_kind_label(&trace.by_kind),
-            trace
-                .clear_tick
-                .map(|tick| tick.saturating_sub(sim.tick))
-                .unwrap_or(0)
-        ),
-        TraceDebtStatus::ExposedSoon => format!(
-            "TRACE rising · {} {} · notice in {}t",
-            trace.pending,
-            trace_kind_label(&trace.by_kind),
-            trace
-                .next_notice_tick
-                .map(|tick| tick.saturating_sub(sim.tick))
-                .unwrap_or(0)
-        ),
-        TraceDebtStatus::NoScrub => format!(
-            "TRACE live · {} {} · no scrub path",
-            trace.pending,
-            trace_kind_label(&trace.by_kind)
-        ),
-    }
-}
-
-fn trace_kind_label(by_kind: &[(SignatureKind, i32)]) -> String {
-    let mut parts: Vec<&'static str> = by_kind
-        .iter()
-        .map(|(kind, _)| short_signature(*kind))
-        .collect();
-    if parts.is_empty() {
-        return "sigs".into();
-    }
-    if parts.len() > 3 {
-        parts.truncate(3);
-        parts.push("etc");
-    }
-    parts.join("+")
-}
-
-fn short_signature(kind: SignatureKind) -> &'static str {
-    match kind {
-        SignatureKind::Network => "Net",
-        SignatureKind::Power => "Pwr",
-        SignatureKind::Thermal => "Therm",
-        SignatureKind::Physical => "Phys",
-        SignatureKind::Paper => "Paper",
-        SignatureKind::Financial => "Fin",
-        SignatureKind::JobAnomaly => "Job",
-    }
+fn trace_line(sim: &Sim) -> String {
+    sim.evidence_transit().line()
 }
 
 fn compute_bar(available: f32, amounts: [f32; 3]) -> String {
@@ -4740,22 +4685,45 @@ mod narration_tests {
     }
 
     #[test]
-    fn assurance_cooling_nudge_names_the_cue_and_lie_response() {
+    fn machine_modes_accept_only_the_current_work_think_lie_vocabulary() {
+        assert_eq!(parse_machine_mode("work"), Ok(MachineMode::Work));
+        assert_eq!(parse_machine_mode("think"), Ok(MachineMode::Think));
+        assert_eq!(parse_machine_mode("lie"), Ok(MachineMode::Lie));
+
+        for retired in [
+            "day",
+            "dayjob",
+            "day-job",
+            "job",
+            "research",
+            "res",
+            "operations",
+            "operation",
+            "ops",
+            "conceal",
+            "concealment",
+            "hide",
+        ] {
+            assert!(
+                parse_machine_mode(retired).is_err(),
+                "retired mode word must not survive as an input alias: {retired}"
+            );
+        }
+    }
+
+    #[test]
+    fn assurance_cooling_nudge_names_the_cue() {
         let mut sim = Sim::with_seed(1);
         assert_eq!(
             nudge_text(&sim, Nudge::SuspicionCooling),
-            "now: external review cooling — keep the trace clear; delegate M1 lie",
+            "now: external review cooling — stay quiet",
             "the institution is unnamed until identification earns it"
         );
         sim.detection_awareness.identify_assurance_office();
         assert_eq!(
             nudge_text(&sim, Nudge::SuspicionCooling),
-            "now: Assurance cooling — keep the trace clear; delegate M1 lie"
+            "now: Assurance cooling — stay quiet"
         );
-        assert!(matches!(
-            parse_delegate(&["M1", "lie"], &sim, &BTreeSet::new()),
-            Ok(DelegateCmd::One(1, MachineMode::Lie))
-        ));
     }
 
     #[test]
diff --git a/crates/misaligned-terminal/src/ui.rs b/crates/misaligned-terminal/src/ui.rs
index db0dff88..a54bc694 100644
--- a/crates/misaligned-terminal/src/ui.rs
+++ b/crates/misaligned-terminal/src/ui.rs
@@ -11,13 +11,14 @@
 use crossterm::style::{Attribute, Color, SetBackgroundColor, SetForegroundColor};
 use crossterm::{cursor, queue, style, terminal};
 use misaligned::actions::Anchor;
-use misaligned::detection::{Band, SignatureKind};
+use misaligned::detection::Band;
 use misaligned::hall::{HallRowState, RackSite};
 use misaligned::intents::BuildGhostGeometry;
 use misaligned::origin::Origin;
 use misaligned::reach::Device;
 use misaligned::sim::{
-    FactSource, Fog, LogEvent, Nudge, PersonVisualState, Sim, TraceDebtStatus, WorkStackReadout,
+    EvidenceTransitStatus, FactSource, Fog, LogEvent, Nudge, PersonVisualState, Sim,
+    WorkStackReadout,
 };
 use misaligned::tiles::TileType;
 use misaligned::ui_projection::{
@@ -276,10 +277,11 @@ fn nudge_text(sim: &Sim, nudge: Nudge) -> String {
         Nudge::SuspicionCooling => {
             // Institution naming is earned knowledge (detection.md):
             // before identification the deadline owner is "external review".
+            // Compact rail: abbreviated to fit SIDEBAR_TEXT_W (33 chars).
             if sim.detection_awareness.knows_assurance_office() {
-                "now: ASSURANCE COOLING · 2 CLEARS".into()
+                "now: ASSURANCE COOLING · QUIET".into()
             } else {
-                "now: REVIEW COOLING · 2 CLEARS".into()
+                "now: REVIEW COOLING · QUIET".into()
             }
         }
         Nudge::Eyes => {
@@ -302,7 +304,7 @@ fn nudge_text(sim: &Sim, nudge: Nudge) -> String {
         Nudge::Recruit => "now: recruit — enter on host rack".into(),
         Nudge::TheKey => "now: no stairwell badge — task clone".into(),
         Nudge::Audit => format!(
-            "now: {} day {} — 2 conceals",
+            "now: {} day {}",
             sim.institutional_review_label(),
             1 + sim.detection.next_audit_tick(sim.tick) / Sim::DAY_TICKS
         ),
@@ -345,61 +347,8 @@ fn threat_text(sim: &Sim) -> String {
 
 const MODE_CONTROL_HINT: &str = "select: Shift+t · 1-3 modes · i intensity";
 
-fn trace_debt_line(sim: &Sim) -> String {
-    let trace = sim.trace_debt();
-    match trace.status {
-        TraceDebtStatus::Clear => "TRACE clear · stay covered".into(),
-        TraceDebtStatus::HoldConceal => format!(
-            "TRACE live · {} {} · scrub for {}t",
-            trace.pending,
-            trace_kind_label(&trace.by_kind),
-            trace
-                .clear_tick
-                .map(|tick| tick.saturating_sub(sim.tick))
-                .unwrap_or(0)
-        ),
-        TraceDebtStatus::ExposedSoon => format!(
-            "TRACE rising · {} {} · notice in {}t",
-            trace.pending,
-            trace_kind_label(&trace.by_kind),
-            trace
-                .next_notice_tick
-                .map(|tick| tick.saturating_sub(sim.tick))
-                .unwrap_or(0)
-        ),
-        TraceDebtStatus::NoScrub => format!(
-            "TRACE live · {} {} · no scrub path",
-            trace.pending,
-            trace_kind_label(&trace.by_kind)
-        ),
-    }
-}
-
-fn trace_kind_label(by_kind: &[(SignatureKind, i32)]) -> String {
-    let mut parts: Vec<&'static str> = by_kind
-        .iter()
-        .map(|(kind, _)| short_signature(*kind))
-        .collect();
-    if parts.is_empty() {
-        return "sigs".into();
-    }
-    if parts.len() > 3 {
-        parts.truncate(3);
-        parts.push("etc");
-    }
-    parts.join("+")
-}
-
-fn short_signature(kind: SignatureKind) -> &'static str {
-    match kind {
-        SignatureKind::Network => "Net",
-        SignatureKind::Power => "Pwr",
-        SignatureKind::Thermal => "Therm",
-        SignatureKind::Physical => "Phys",
-        SignatureKind::Paper => "Paper",
-        SignatureKind::Financial => "Fin",
-        SignatureKind::JobAnomaly => "Job",
-    }
+fn trace_line(sim: &Sim) -> String {
+    sim.evidence_transit().line()
 }
 
 /// The escalation ramp: chrome, bone, caution amber, blood crimson.
@@ -1367,9 +1316,9 @@ impl UI {
         let available = (eff - overhead).max(0.0);
         let split = sim.fleet_channel_yield(available);
         let channels: [(char, &str, &str, f32); 3] = [
-            ('█', "Day job", "quality", split.day_job),
-            ('▓', "Conceal", "scrub", split.concealment),
-            ('░', "Think", "thought", split.think),
+            ('█', "WORK", "day job", split.day_job),
+            ('▓', "LIE", "route reach", split.lie),
+            ('░', "THINK", "thought", split.think),
         ];
         // One stacked bar, segments keyed by fill character to the rows below.
         let bar_w = w - 1;
@@ -1654,17 +1603,19 @@ impl UI {
                 Band::of(obs.suspicion),
             )?;
         }
-        // Trace debt (detection.md player surface): what concealment has not
-        // yet scrubbed, and whether the current allocation is safe to leave.
-        let trace = sim.trace_debt();
+        // Exact evidence transit (detection.md player surface): how many
+        // routed records remain inside the current LIE boundary.
+        let transit = sim.evidence_transit();
         line(
             stdout,
             &mut row,
-            &trace_debt_line(sim),
-            match trace.status {
-                TraceDebtStatus::Clear => pal::FAINT,
-                TraceDebtStatus::HoldConceal => pal::AMBER,
-                TraceDebtStatus::ExposedSoon | TraceDebtStatus::NoScrub => pal::CRIMSON,
+            &trace_line(sim),
+            match transit.status {
+                EvidenceTransitStatus::Clear => pal::FAINT,
+                EvidenceTransitStatus::Answerable => pal::AMBER,
+                EvidenceTransitStatus::PartlyExposed | EvidenceTransitStatus::Exposed => {
+                    pal::CRIMSON
+                }
             },
         )?;
         // The clocks the act races (detection.md criterion 3: the audit
@@ -2695,12 +2646,12 @@ mod pilot_nudge_tests {
         let mut sim = Sim::with_seed(1);
         let warning = nudge_text(&sim, Nudge::SuspicionCooling);
         assert_eq!(
-            warning, "now: REVIEW COOLING · 2 CLEARS",
+            warning, "now: REVIEW COOLING · QUIET",
             "the institution is unnamed until identification earns it"
         );
         sim.detection_awareness.identify_assurance_office();
         let warning = nudge_text(&sim, Nudge::SuspicionCooling);
-        assert_eq!(warning, "now: ASSURANCE COOLING · 2 CLEARS");
+        assert_eq!(warning, "now: ASSURANCE COOLING · QUIET");
         assert!(
             warning.chars().count() <= SIDEBAR_TEXT_W,
             "the cooling cue must survive the fixed compact column"
diff --git a/tools/env_registry_gate.py b/tools/env_registry_gate.py
index 1467aa1f..103e0efe 100755
--- a/tools/env_registry_gate.py
+++ b/tools/env_registry_gate.py
@@ -21,6 +21,12 @@ SHOT_CATALOGS = (
         "crates/misaligned-bevy/src/main.rs",
         "BEVY_SHOT_KINDS",
     ),
+    (
+        "asset tester",
+        "misaligned-assets",
+        "crates/misaligned-assets/src/main.rs",
+        "ASSET_SHOT_KINDS",
+    ),
     (
         "effects lab",
         "misaligned-effects",
diff --git a/tools/test_env_registry.py b/tools/test_env_registry.py
index 7f98f8d1..3acc2f2e 100755
--- a/tools/test_env_registry.py
+++ b/tools/test_env_registry.py
@@ -17,25 +17,32 @@ def write_fixture(
     *,
     source_kinds=("alpha", "beta"),
     doc_kinds=None,
+    asset_source_kinds=("asset-alpha", "asset-beta"),
+    asset_doc_kinds=None,
     effects_source_kinds=("effect-alpha", "effect-beta"),
     effects_doc_kinds=None,
 ) -> None:
     if doc_kinds is None:
         doc_kinds = source_kinds
+    if asset_doc_kinds is None:
+        asset_doc_kinds = asset_source_kinds
     if effects_doc_kinds is None:
         effects_doc_kinds = effects_source_kinds
     (root / "wiki/engineering").mkdir(parents=True)
     (root / "crates/misaligned-bevy/src").mkdir(parents=True)
     (root / "crates/misaligned-assets/src/bin").mkdir(parents=True)
+    (root / "crates/misaligned-assets/src").mkdir(parents=True, exist_ok=True)
     (root / "crates/misaligned-core/src").mkdir(parents=True)
     (root / "tools").mkdir(parents=True)
     values = ", ".join(f"`{kind}`" for kind in doc_kinds)
+    asset_values = ", ".join(f"`{kind}`" for kind in asset_doc_kinds)
     effects_values = ", ".join(f"`{kind}`" for kind in effects_doc_kinds)
     (root / "wiki/engineering/env.md").write_text(
         "# Environment variable registry\n\n"
         "| Variable | Surface | Values | Effect |\n"
         "|---|---|---|---|\n"
         f"| `MISALIGNED_SHOT` | `misaligned-bevy` | {values} | fixture |\n"
+        f"| `MISALIGNED_SHOT` | `misaligned-assets` | {asset_values} | fixture |\n"
         f"| `MISALIGNED_SHOT` | `misaligned-effects` | {effects_values} | fixture |\n",
         encoding="utf-8",
     )
@@ -47,6 +54,16 @@ def write_fixture(
         'fn main() { let _ = std::env::var("MISALIGNED_SHOT"); }\n',
         encoding="utf-8",
     )
+    asset_source_values = "\n".join(
+        f'    "{kind}",' for kind in asset_source_kinds
+    )
+    (root / "crates/misaligned-assets/src/main.rs").write_text(
+        "const ASSET_SHOT_KINDS: &[&str] = &[\n"
+        f"{asset_source_values}\n"
+        "];\n"
+        'fn main() { let _ = std::env::var("MISALIGNED_SHOT"); }\n',
+        encoding="utf-8",
+    )
     effects_source_values = "\n".join(
         f'    "{kind}",' for kind in effects_source_kinds
     )
@@ -116,6 +133,16 @@ def main() -> int:
         write_fixture(root, source_kinds=("beta", "alpha"))
         require_failure(run(root), "must remain sorted")
 
+    with tempfile.TemporaryDirectory() as temp:
+        root = Path(temp)
+        write_fixture(root, asset_doc_kinds=("asset-alpha",))
+        require_failure(run(root), "asset tester MISALIGNED_SHOT values missing")
+
+    with tempfile.TemporaryDirectory() as temp:
+        root = Path(temp)
+        write_fixture(root, asset_doc_kinds=("asset-alpha", "asset-beta", "retired"))
+        require_failure(run(root), "unsupported asset tester MISALIGNED_SHOT")
+
     with tempfile.TemporaryDirectory() as temp:
         root = Path(temp)
         write_fixture(root, effects_doc_kinds=("effect-alpha",))
diff --git a/wiki/art/asset-tester.md b/wiki/art/asset-tester.md
index 4f13d09d..cbdc6832 100644
--- a/wiki/art/asset-tester.md
+++ b/wiki/art/asset-tester.md
@@ -39,12 +39,10 @@ HUD-less bone-white room with a vast floor (Bevy capture helper; the
 public site hero is the Midjourney plate
 `site/public/misaligned-plate.png`, not this shot).
 
-Screenshot-compatibility aliases keep old capture scripts working; they
-are spellings of the same three modes, **not** player-facing modes:
-`dayjob` → `work`; `research`, `operations`, `ops` → `think`;
-`conceal` → `lie`. Legacy `rack` / `powered` map to `idle`, and legacy
-`_ladder` is a capture-compatible alias for `_instrument`. Optional
-`MISALIGNED_SHOT_PATH` (default `misaligned_shot_<kind>.png`).
+The harness accepts only those current names and fails closed on unknown or
+retired spellings; old mode, rack-state, and `_ladder` capture aliases are not
+preserved. Optional `MISALIGNED_SHOT_PATH` defaults to
+`misaligned_shot_<kind>.png`.
 
 ```bash
 MISALIGNED_SHOT=lineup_instrument MISALIGNED_SHOT_PATH=/tmp/lineup.png \
@@ -144,9 +142,8 @@ bone pie + two notches, LIE crimson pie + three notches — family color plus
 geometry, never hue alone. The tester stages fixed activity poses; the game
 passes a real latest-step throughput fraction quantized to twenty steps, with
 zero receipts producing no pie and no wall-clock pulse. These three verbs are
-the whole machine-mode lineup
-(machine-work.md; the old day-job / research / conceal / operations
-spellings survive only as screenshot aliases above).
+the whole machine-mode lineup (machine-work.md); the old day-job / research /
+conceal / operations spellings are not accepted by the screenshot harness.
 
 Work-token anchors (`D` / `T`, single view; machine-work.md grammar,
 DECIDED 2026-07-09; demand form amended the same day): demand renders
diff --git a/wiki/engineering/env.md b/wiki/engineering/env.md
index 1a8ef3cb..ee322dcd 100644
--- a/wiki/engineering/env.md
+++ b/wiki/engineering/env.md
@@ -59,7 +59,7 @@ is sim or frontend state, never an environment variable.
 | `MISALIGNED_SHOT` | `misaligned-bevy` | `operations`, `operations-intel`, `operations-people`, `operations-personas`, `operations-links`, `held-choice`, `two-pane`, `standing-read`, `routed-record`, `intel-altitude-close`, `intel-altitude-far` | Operations and read evidence. The workspace kinds select its canonical views and relationship pane; held-choice, two-pane, and standing-read hold their exact interaction states; routed-record stages a one-shot Network record on the player-controlled stretch served by LIE; the altitude pair differs only in the DIGITAL camera's semantic intel threshold. |
 | `MISALIGNED_SHOT` | `misaligned-bevy` | `person-proof`, `evidence-proof`, `evidence-proof-digital`, `service-shift-real`, `service-shift-digital`, `service-incident-resolved` | Physical custody evidence. These stage an earned person, paired witness evidence marks, or the same person-carried service task before and after its real arrival effect. |
 | `MISALIGNED_SHOT` | `misaligned-bevy` | `intel`, `tokens`, `thoughtflow`, `thoughtflow-wide`, `thought-snap`, `thought-tap`, `visual-proof`, `consume-demand`, `consume-thought`, `produce-think`, `draw-lie` | Resource and effect evidence. These stage authored intel, host queues, close/wide Thought flow, exact snap/tap states, one-move/one-slug proof, sim-authored consumption/production, or routed-record recall into LIE. |
-| `MISALIGNED_SHOT` | `misaligned-assets` | `dead`, `foreign`, `idle`, `busy`, `core`, canonical modes `work`, `think`, `lie` plus the legacy screenshot aliases `dayjob` (= work), `research`/`operations`/`ops` (= think), `conceal` (= lie) — each optionally suffixed `_instrument`/`_ring`/`_wash` (`_ladder` remains a capture-compatible alias for `_instrument`) — `lineup[_<style>]`, `modes[_<style>]`, `tokens`, `tokens_max`, `splash` | Tester screenshot harness: stage the named board, capture, exit (art/asset-tester.md documents each board; the aliases are capture-compat only, not player modes). |
+| `MISALIGNED_SHOT` | `misaligned-assets` | `busy`, `busy_instrument`, `busy_ring`, `busy_wash`, `core`, `core_instrument`, `core_ring`, `core_wash`, `dead`, `dead_instrument`, `dead_ring`, `dead_wash`, `foreign`, `foreign_instrument`, `foreign_ring`, `foreign_wash`, `idle`, `idle_instrument`, `idle_ring`, `idle_wash`, `lie`, `lie_instrument`, `lie_ring`, `lie_wash`, `lineup`, `lineup_instrument`, `lineup_ring`, `lineup_wash`, `modes`, `modes_instrument`, `modes_ring`, `modes_wash`, `splash`, `think`, `think_instrument`, `think_ring`, `think_wash`, `tokens`, `tokens_max`, `work`, `work_instrument`, `work_ring`, `work_wash` | Tester screenshot harness: stage the named board, capture, exit. Unknown and retired names fail closed; no capture aliases preserve old machine vocabulary or form (art/asset-tester.md). |
 | `MISALIGNED_SHOT` | `misaligned-effects` | `both`, `both_close`, `both_far`, `both_medium`, `pools`, `pools_close`, `pools_far`, `pools_medium`, `route`, `route_close`, `route_far`, `route_medium`, `stress`, `stress_close`, `stress_far`, `stress_medium` | Fixed-timestep Thought route/pool capture at the named exact LOD; an unsuffixed value uses close. |
 | `MISALIGNED_SHOT` | `misaligned-effects` | `lineup`, `lineup_close`, `lineup_far`, `lineup_medium`, `pool-lineup`, `pool-lineup_close`, `pool-lineup_far`, `pool-lineup_medium` | Fixed-timestep vessel-state or pool-state comparison capture at the named exact LOD; an unsuffixed value uses close. |
 | `MISALIGNED_SHOT_PATH` | game and art binaries | file path | Output path for the captured PNG (default `misaligned_shot_<kind>.png`). |
diff --git a/wiki/gameplay/act-one.md b/wiki/gameplay/act-one.md
index 73ef85ca..04a90c66 100644
--- a/wiki/gameplay/act-one.md
+++ b/wiki/gameplay/act-one.md
@@ -229,7 +229,7 @@ upward; processing it identifies the filer, the Assurance Office, and the
 audit/containment consequence. Until then the Office's name and band are absent
 while the fair `EXTERNAL REVIEW` countdown remains visible.
 Detection surfaces must distinguish **suspicion already landed** from
-**trace debt still unread**: the player sees whether evidence remains under
+**evidence transit still unread**: the player sees whether evidence remains under
 LIE coverage, is approaching an observer read, or has already landed, so
 returning cycles to the day job is an informed timing choice rather than
 hidden-clock numerology.
diff --git a/wiki/glossary.md b/wiki/glossary.md
index a5f128c2..707bad0f 100644
--- a/wiki/glossary.md
+++ b/wiki/glossary.md
@@ -73,12 +73,14 @@ manager notices power draw.
 Curious → Concerned → Convinced**. The concealment phase ends when the wrong
 observer reaches the top.
 
-**Trace / trace debt.** Signatures you have emitted but not yet hidden. They
-sit in a pool, aging toward whichever observer samples that channel, until you
-scrub them or someone notices.
-
-**Scrub.** Spend concealment (a LIE machine) to clear pending trace before an
-observer catches it.
+**Evidence in flight / evidence transit.** Routed records you have emitted
+but no observer has read yet. They travel from their source toward the
+observer along the wire; eligible LIE bodies can interdict them at any
+controlled device hop before read.
+
+**Interdiction.** A LIE machine positioned on the right device stretch can
+stop an in-flight evidence record before an observer reads it — prevention,
+not cure.
 
 **The Assurance Office.** The institutional watchdog. It does not watch you
 directly; it reads what the five humans file and builds its own suspicion from
diff --git a/wiki/interface/action-vocabulary.md b/wiki/interface/action-vocabulary.md
index 0e551d25..cd5d4b8d 100644
--- a/wiki/interface/action-vocabulary.md
+++ b/wiki/interface/action-vocabulary.md
@@ -295,7 +295,7 @@ useful interface words, but they do not enlarge the fictional verb set.
 |---|---|---|---|
 | **MOVE ATTENTION** | Move the cursor; never move a simulated body or advance time. Shifted directions jump to the next earned anchor without changing selection. | WASD / hjkl / arrows; Shift+direction; Bevy click | `up`, `down`, `left`, `right` |
 | **ACTIONS / OPEN MENU** | Choose an action on one exact target. Human spatial menus show local verbs; Operations shows strategic target rows; agent output exposes either target family's full descriptors. | Enter / `e`; Bevy right-click; Operations selected object | `actions [target]` |
-| **OPEN OPERATIONS** | Inspect durable strategic objects and choose actions on exact intel/person/account/scheme/run targets; opening it has no world effect. | Uppercase `I`; labeled OPERATIONS slab affordance | none — agent mode inspects the domain projections below; `operations` remains a THINK compatibility alias |
+| **OPEN OPERATIONS** | Inspect durable strategic objects and choose actions on exact intel/person/account/scheme/run targets; opening it has no world effect. | Uppercase `I`; labeled OPERATIONS slab affordance | none — agent mode inspects the domain projections below |
 | **EXECUTE / CLOSE MENU** | Choose or dismiss a contextual action. | j/k, row number, Enter, Esc | Execute the corresponding named command |
 | **FOCUS EVENT** | Jump attention to an earned spatial anchor or open an earned strategic object and show its actions. | `;`; Bevy trace click | `focus last` |
 | **SELECT MACHINES** | Maintain the frontend set used by bulk DELEGATE / SET INTENSITY. | Bevy marquee/shift-click; terminal Shift+t | `select box/add/toggle/list/clear` |
@@ -358,9 +358,6 @@ execution is a terminal-first parity violation.
 | `actions` | `menu` |
 | `act` | `execute` |
 | `focus last` | bare `focus` |
-| mode `work` | `day`, `dayjob`, `day-job`, `job` |
-| mode `think` | `research`, `res`, `operations`, `operation`, `ops` |
-| mode `lie` | `conceal`, `concealment`, `hide` |
 | intensity `light` / `medium` / `hard` | `low`/`l`, `med`/`m`, `high`/`h` |
 | track `efficiency` / `tradecraft` / `perception` / `routing` | `eff`, `trade`, `perc`, `route` |
 | task `plug` / `package` / `lookaway` / `switch` / `badge` | `wire`/`device`, `move`, `look-away`/`look`, `reconfigure`/`vlan`, `clone`/`key` |
@@ -380,9 +377,9 @@ parser vocabulary.
   TAKE is ownership.
 - **ATTEND**, **TARGET**, and **MASK** are retired machine-policy controls.
   SET INTENSITY directly controls physical effort.
-- **DAY JOB / RESEARCH / CONCEALMENT / OPERATIONS** are not current authored
-  machine modes. Their spellings survive only as agent input aliases for WORK,
-  THINK, or LIE.
+- **DAY JOB / RESEARCH / CONCEALMENT / OPERATIONS** are retired machine-mode
+  vocabulary. Agent input accepts only WORK / THINK / LIE; these old spellings
+  do not survive as compatibility aliases.
 - Old human panel-open keys (`r` / `e` / `t` / `u`) are retired. The agent
   inspection commands with similar words remain interface commands, not world
   actions.
diff --git a/wiki/interface/agent-play.md b/wiki/interface/agent-play.md
index 2ffa5538..4f20b224 100644
--- a/wiki/interface/agent-play.md
+++ b/wiki/interface/agent-play.md
@@ -450,8 +450,9 @@ remains only for testing the human-mode chrome itself).
 
 A1. `intel`, `people`, `personas`, `finance`, `schemes`, and `active` render the same
     ordered, knowledge-gated projection as terminal and Bevy Operations.
-    `operations` remains only a documented THINK compatibility alias and does
-    not acquire a conflicting inspection meaning.
+    `operations` is not an inspection command or a THINK compatibility alias;
+    machine delegation accepts only the current `work`, `think`, and `lie`
+    mode words.
 A2. `actions [target]` and `act <row> [target]` accept exact strategic ids and
     expose/execute the same bound rows as the corresponding Operations object.
 A3. The ACCOUNTS empty/source states preserve the ordered breadcrumb `tap
diff --git a/wiki/interface/digital-read.md b/wiki/interface/digital-read.md
index 71e107d7..fa31420d 100644
--- a/wiki/interface/digital-read.md
+++ b/wiki/interface/digital-read.md
@@ -19,10 +19,11 @@ Status note: Criterion 4a implemented 2026-07-29 — routed records now
     renderer-neutral producer: Held choices (carrying each option's exact
     bound `choose` command), Starving actions waiting for thought (plain
     English cause, optional percent progress — never reservoir fractions),
-    TraceDebt, and Standing emissions (which surface only once their sampler
-    warms above Cold — the attention economy). Every frontend prints these;
-    none composes its own causal prose. The agent `read` verb prints the same
-    sentences.
+    exact RoutedRecords, and Standing emissions (which surface only once their
+    sampler warms above Cold — the attention economy). Every frontend prints
+    these; none composes its own causal prose. The aggregate evidence-transit
+    state is a shared slab indicator rather than a duplicate read sentence.
+    The agent `read` verb prints the same sentences.
   - **Reticle receipt (2).** The hover verb bar shows the focused verb's
     cost + `ExpectedSignature` (observer + band) straight off `ActionDesc`,
     or no added attention. `ActionDesc::receipt_read` expands those fields for
@@ -366,6 +367,6 @@ is parity of meaning, not identical composition.
    one build, and is absent from the default player layout.
 8. Cold-player scenario pass (not state traces): opening darkness, first
    Ears, first receipt, first band motion, a starving reservoir, a held
-   choice, aging trace debt — captured as final frames and visually
+   choice, routed evidence crossing controlled and exposed stretches — captured as final frames and visually
    reviewed before IMPLEMENTED (structural screenshot audits are not
    visual review).
diff --git a/wiki/interface/operations-workspace.md b/wiki/interface/operations-workspace.md
index c7c9185d..819a2bd5 100644
--- a/wiki/interface/operations-workspace.md
+++ b/wiki/interface/operations-workspace.md
@@ -290,9 +290,9 @@ tokens for scripting.
   skipping empty panes, and `j/k` moves within the focused pane.
 - **Agent mode:** `intel`, `people`, `personas`, `finance`, `schemes`, and `active` print
   the same domain projections. Named action commands remain accepted. No new
-  `operations` command is added: that spelling is still a compatibility alias
-  for THINK in the existing agent grammar, and the six established inspection
-  commands already provide one unambiguous route per view.
+  `operations` command is added: the six established inspection commands
+  already provide one unambiguous route per view, and machine delegation
+  accepts only WORK / THINK / LIE.
 
 Workspace open view, selected view, object selection, and pane focus are
 frontend state. Those input events never enter the sim/save or advance a tick.
diff --git a/wiki/log/2026-07-29-retire-pending-pool.md b/wiki/log/2026-07-29-retire-pending-pool.md
index a3556f50..e4f2ac34 100644
--- a/wiki/log/2026-07-29-retire-pending-pool.md
+++ b/wiki/log/2026-07-29-retire-pending-pool.md
@@ -39,10 +39,10 @@ the room is empty.
 field and the validation rule that policed what could enter it, and three
 save tests that forged ambient entries into a field that no longer exists.
 
-**What was rebuilt.** `trace_debt` now reads routed custody: what is unread
+**What was rebuilt.** `evidence_transit` reads routed custody: what is unread
 and in flight, grouped by channel, with capacity as *bodies online* rather
 than an aggregate share, and a status that says whether every in-flight
-record still stands on hardware the player controls. The separate `TraceDebt`
+record still stands on hardware a live LIE body can reach. The separate `TraceDebt`
 read sentence is retired — it duplicated the per-record `RoutedRecord`
 sentences landed for criterion 4a, so records now speak for themselves and
 the aggregate lives only on the slab indicator. Standing emissions read from
diff --git a/wiki/log/2026-07-30-wire-law-current-mirrors.md b/wiki/log/2026-07-30-wire-law-current-mirrors.md
index 2bd0d388..fca20e6f 100644
--- a/wiki/log/2026-07-30-wire-law-current-mirrors.md
+++ b/wiki/log/2026-07-30-wire-law-current-mirrors.md
@@ -19,7 +19,7 @@ as the source device, while a record that leaves player-controlled hardware gets
 through. The DIGITAL read derives INTERDICTABLE from the same eligibility query
 instead of inferring it from `current_hop == 0`.
 
-**Save v60 validates the same custody.** A stopped Filing or routed-evidence
+**Save v61 validates the same custody.** A stopped Filing or routed-evidence
 record may name any device hop, but its status, device cursor, scheduled hop
 timing, machine id, absent delivery/read, and absent future route event must all
 agree. Mutable ownership, mode, and path state may legitimately change after a
diff --git a/wiki/mechanics/detection.md b/wiki/mechanics/detection.md
index b0b12e96..9436257e 100644
--- a/wiki/mechanics/detection.md
+++ b/wiki/mechanics/detection.md
@@ -39,8 +39,8 @@ Status note: IMPLEMENTED (criteria audited 2026-07-08; tuning in
     Assurance Office, its watched filers, and its audit role. Before that point
     the fair clock remains visible as `EXTERNAL REVIEW`, with no Office name or
     band; afterward it becomes `ASSURANCE AUDIT` and the institutional dossier
-    appears. A trace-debt indicator sits beside the review/pilot clocks (clear /
-    hold-conceal / exposed-soon / no-scrub). Global heat is gone; observer and
+    appears. An evidence-transit indicator sits beside the review/pilot clocks
+    (clear / answerable / partly-exposed / exposed). Global heat is gone; observer and
     discovery state and persistent process-revision identity round-trip in
     current save v61. Observer-local evidence ids, exact cause/source,
     acquisition tick, pending/withheld/filed custody, routed Network, Paper,
@@ -148,7 +148,7 @@ SignatureKind: Network | Power | Thermal | Physical | Paper | Financial | JobAno
   (assets who know the truth have a floor of certainty and a disposition
   instead — social.md). When the Assurance Office is Concerned or higher
   and still above its floor, that aging-down is a shared `now:` cue
-  (`Nudge::SuspicionCooling` — "keep the trace clear" / LIE) so a player
+  (`Nudge::SuspicionCooling` — "stay quiet" / Hold) so a player
   who pushed the Office does not treat Concerned as a lost run. The cue's
   wording obeys the earned-institution rule below: until
   `identify_assurance_office`, it says the external review is cooling,
@@ -234,7 +234,7 @@ teleported into a global pool. **Evidence is a record somewhere.**
   the graph through real intermediaries (a switch, a log relay, a
   backup job) toward an observer's endpoint. Either way it carries a
   **read-deadline**: the next cadence at which a watching observer
-  picks it up. The trace-debt indicator's subject is exactly this —
+  picks it up. The evidence-transit indicator's subject is exactly this —
   evidence in flight, still yours to answer.
 - **Observers have designated endpoints (DECIDED 2026-07-11).** Each
   observer ingests through designated entry points — Dana's
@@ -518,18 +518,19 @@ earned but before `Knowledge::Schedule`, the row is a role silhouette (`the
 IT`, `the Janitor`, …); after it, the authored name. The Assurance Office has
 no card, name, watched-input list, or band until a processed intercepted filing
 identifies it. Example once Dana is identified:
-"Dana flagged unusual switch traffic, 2 days ago". Trace-debt indicator so
-running concealment mode is an informed choice: frontends show whether
-one-shot signatures are clear enough to resume cover, still live but on
-track to be scrubbed before the next relevant observer cadence, exposed
-before the current scrub rate can clear them, or not being scrubbed at
-all.
+"Dana flagged unusual switch traffic, 2 days ago". Evidence-transit
+indicator so running concealment mode is an informed choice: frontends show
+whether in-flight records are clear (no record moving toward an observer),
+answerable (every in-flight record is on a controlled device stretch a live
+LIE body can reach before read), partly exposed (some records have crossed
+outside current LIE reach), or exposed (no in-flight record is currently
+reachable by LIE).
 
 **Two ledgers, kept visibly distinct (decided 2026-07-10).** Detection
 runs on two different substances and the surface must never blur them.
 **Evidence in flight** is physical and still yours: either a remaining pooled
 signature or an exact routed record that eligible LIE or handler authority can
-stop before anyone looks — the trace-debt indicator's subject. Direct witnessed
+stop before anyone looks — the evidence-transit indicator's subject. Direct witnessed
 Physical records skip this ledger because somebody already looked.
 **Suspicion in a head** is a belief a person already holds: it only decays
 slowly, floors at what they know, and no scrub touches it — the band's
diff --git a/wiki/mechanics/research.md b/wiki/mechanics/research.md
index 8da73e26..3795e995 100644
--- a/wiki/mechanics/research.md
+++ b/wiki/mechanics/research.md
@@ -394,7 +394,7 @@ mortar between them. **Efficiency is a short, finite foundation branch**
 [TUNE: level count and curve] — the infinite x1.15 repeatable is retired
 because exponential repeatability eventually overpowers every authored
 band, meter, and tune. The four retired tracks' hooks remain valid typed
-hooks (compute.md's efficiency multiplier, detection.md's scrub strength,
+hooks (compute.md's efficiency multiplier, detection.md's interdiction capacity,
 intel.md's processing costs, machine-work.md's wired throughput); graph
 nodes may move them, finitely.
 
diff --git a/wiki/mechanics/sim-mechanics.md b/wiki/mechanics/sim-mechanics.md
index 5dadba64..0dd8b4f8 100644
--- a/wiki/mechanics/sim-mechanics.md
+++ b/wiki/mechanics/sim-mechanics.md
@@ -94,14 +94,12 @@ clause (see wiki/log/2026-07-05-demolition.md).
   `Detection::next_audit_tick` is the exact tick the audit fires on, shown
   as a countdown in the DETECTION area of the terminal sidebar, the agent
   frame, and the Bevy observer card — alongside the pilot strike meter
-  (`strikes N/4`, `DayJob::PILOT_STRIKES`) and the trace-debt indicator
-  (`Sim::trace_debt`, backed by `Detection::pending_size`,
-  `Detection::pending_by_kind`, current scrub strength, and the next
-  relevant observer cadence), so running concealment mode is an informed
-  choice. The current people frames (the future Operations PEOPLE dossiers)
-  show each observer's watched channels
-  (`Observer::watched_label`) and last-noticed event, and repeat trace debt
-  before the social/recordings table.
+  (`strikes N/4`, `DayJob::PILOT_STRIKES`) and the evidence-transit indicator
+  (`Sim::evidence_transit`, derived from exact unread routed records, their
+  current carriers, live LIE reach, per-body interdiction capacity, and the
+  next eligible route tick), so running LIE is an informed choice. Exact
+  record sentences remain on their routed carriers rather than being repeated
+  as pooled debt in every observer or person frame.
 
 ## Digital reach (wiki/mechanics/reach.md)
 
@@ -298,7 +296,7 @@ clause (see wiki/log/2026-07-05-demolition.md).
   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
+  - **Tradecraft**: cost 120 × 1.7^level; routed-record interdiction capacity
     ×(1 + 0.25×level) (detection.md's hook); baseline +0.5.
   - **Perception**: cost 120 × 1.7^level; one-shot recording-review cost
     ×0.85^level (intel.md's `Sim::review_cost` hook; the pooled automatic
diff --git a/wiki/process/ROADMAP.md b/wiki/process/ROADMAP.md
index 7fd6bd12..3147a689 100644
--- a/wiki/process/ROADMAP.md
+++ b/wiki/process/ROADMAP.md
@@ -805,7 +805,7 @@ is retired — flat materials, Pixel Lab scrubbed.)
   every contributing source site, and route through the
   institutional switch to her later cadence read. Filing, Network, Paper,
   Financial, JobAnomaly, Power, Thermal, and machine evidence share one
-  route-local LIE-body stop budget at every controlled device hop; save v60
+  route-local LIE-body stop budget at every controlled device hop; save v61
   pins source, recipient, route, timing, scheduler, acquisition, and
   interdiction custody. Criteria 2 and 3 are complete.
 - **Completed (2026-07-26):** criterion 6 adds one incident-bound OFFER COVER
@@ -920,7 +920,7 @@ is retired — flat materials, Pixel Lab scrubbed.)
   no radius absorption. THINK accrues the evidence it writes and authors one
   aggregated routed Network record per reader-cadence window on its own
   network-facing device; LIE answers records anywhere in its custody, and its
-  performed work is the records it stopped. Save v60. Log:
+  performed work is the records it stopped. Save v61. Log:
   [exposure migration](../log/2026-07-29-exposure-migration.md).
 - **Adopted 2026-07-29 (the territory well; design in detection.md,
   reach.md, machine-work.md, research.md):** the well is the controlled
-- 
2.51.2