diff --git a/src/bin/bevy.rs b/src/bin/bevy.rs
index 2b0539b..190c368 100644
--- a/src/bin/bevy.rs
+++ b/src/bin/bevy.rs
@@ -219,6 +219,12 @@ impl Game {
         self.cursor_x = x.clamp(0, self.sim.map.width - 1);
         self.cursor_y = y.clamp(0, self.sim.map.height - 1);
     }
+    /// Attendance follows the cursor (day-job.md criterion 7): the job
+    /// runs attended exactly while the cursor sits on the host rack.
+    fn sync_attendance(&mut self) {
+        let on_host = (self.cursor_x, self.cursor_y) == self.sim.core_position();
+        self.sim.set_attended(on_host);
+    }
     fn add_log(&mut self, tick: u64, msg: &str) {
         self.log.push((tick, msg.to_string()));
         let n = self.log.len();
@@ -667,6 +673,8 @@ fn handle_input(
     if kb.just_pressed(KeyCode::KeyQ) {
         exit.write(AppExit::Success);
     }
+    // Cursor moves above may have landed on / left the host rack.
+    game.sync_attendance();
     game.drain();
 }
 
@@ -838,6 +846,11 @@ fn advance_sim(time: Res<Time>, mut game: ResMut<Game>) {
     if game.screen != Screen::Playing || game.paused {
         return;
     }
+    // Attended work follows the cursor (day-job.md criterion 7): re-assert
+    // attendance before time advances so a host migration under a parked
+    // cursor stays honest. The cursor stays frontend state; the sim only
+    // receives the resulting attendance command.
+    game.sync_attendance();
     game.tick_timer.tick(time.delta());
     let steps = (game.tick_timer.times_finished_this_tick() as usize).min(5);
     for _ in 0..steps {
@@ -1434,6 +1447,22 @@ fn sidebar_text(game: &Game) -> String {
             job.target.name(),
             sim.day_job_rate()
         ));
+        // Attended work (day-job.md criterion 7): the job is resident on
+        // the host rack; the cursor parked there runs it attended.
+        if sim.dayjob.attended {
+            s.push_str(&format!(
+                "attended on host rack (+{:.0}%)\n",
+                misaligned::dayjob::DayJob::ATTENDED_BONUS * 100.0
+            ));
+        } else {
+            s.push_str(&format!(
+                "unattended / policy {}\n",
+                sim.dayjob
+                    .standing_policy
+                    .unwrap_or(misaligned::dayjob::JobTarget::Meet)
+                    .name()
+            ));
+        }
     } else {
         s.push_str("idle - no job queued\n");
     }
diff --git a/src/bin/terminal/agent.rs b/src/bin/terminal/agent.rs
index 1caa730..cf73681 100644
--- a/src/bin/terminal/agent.rs
+++ b/src/bin/terminal/agent.rs
@@ -15,7 +15,11 @@ use misaligned::sim::{FactSource, Fog, Sim};
 use misaligned::tiles::TileType;
 
 const WIDTH: usize = 70;
-const HEIGHT: usize = 22;
+/// Frame height. wiki/interface/agent-play.md sets 70x22 as the *minimum*;
+/// the sidebar (INSPECT/COMPUTE/CORE/DETECTION/DAY JOB, agent-play
+/// criterion 5) needs the taller frame to render in full — at 22 rows
+/// everything below COMPUTE was silently truncated.
+const HEIGHT: usize = 54;
 const SIDEBAR_W: usize = 34;
 const MAP_W: usize = WIDTH - SIDEBAR_W - 1;
 const MAP_H: usize = HEIGHT - 9;
@@ -78,6 +82,14 @@ impl AgentApp {
         self.cursor_y = (self.cursor_y + dy).clamp(0, self.sim.map.height - 1);
     }
 
+    /// Attendance is derived from the cursor, deterministically: the job
+    /// runs attended exactly while the cursor sits on the host rack
+    /// (day-job.md criterion 7; wiki/interface/agent-play.md).
+    fn sync_attendance(&mut self) {
+        let on_host = (self.cursor_x, self.cursor_y) == self.sim.core_position();
+        self.sim.set_attended(on_host);
+    }
+
     fn handle_line(&mut self, line: &str, out: &mut impl Write) -> io::Result<bool> {
         let trimmed = line.trim();
         let mut status = Status::Ok;
@@ -104,6 +116,9 @@ impl AgentApp {
                                 if self.sim.game_over {
                                     break;
                                 }
+                                // Re-asserted each tick so a host migration
+                                // under a parked cursor stays honest.
+                                self.sync_attendance();
                                 self.sim.advance();
                             }
                         }
@@ -125,6 +140,15 @@ impl AgentApp {
                         self.frame = FrameKind::Playing;
                         self.move_cursor(1, 0);
                     }
+                    "attend" => {
+                        // Park the cursor on the host rack: the resident
+                        // job runs attended while it stays there; any move
+                        // away drops it to the standing policy.
+                        self.frame = FrameKind::Playing;
+                        let (x, y) = self.sim.core_position();
+                        self.cursor_x = x;
+                        self.cursor_y = y;
+                    }
                     "reach" => {
                         self.frame = FrameKind::Reach;
                     }
@@ -267,6 +291,10 @@ impl AgentApp {
             }
         }
 
+        // Attendance follows the cursor before the frame renders, so the
+        // block the driver reads already reflects any cursor move above.
+        self.sync_attendance();
+
         if self.sim.game_over {
             self.frame = FrameKind::GameOver;
         }
@@ -464,11 +492,12 @@ fn help_lines() -> Vec<String> {
     [
         "help: wait N — advance exactly N ticks unless the run ends",
         "help: up/down/left/right — move the cursor",
+        "help: attend — park the cursor on the host rack (job runs attended there)",
         "help: reach — device graph; scan, compromise — network verbs",
         "help: tap|splice|take <device> — reach verbs on a named device",
         "help: salvage, buy, fallback — map verbs",
         "help: alloc dayjob|conceal|social|research [down] — adjust allocation weight",
-        "help: target sandbag|meet|excel — set the active job's target",
+        "help: target sandbag|meet|excel — the dial: this job when attended, else the standing policy",
         "help: people — render the people panel",
         "help: review|watch|message|favor|bribe|deceive <name> — intel/social verbs",
         "help: recruit <name> unwitting|complicit|knowing — recruit an asset",
@@ -519,7 +548,15 @@ fn render_playing(sim: &Sim, log: &[(u64, String)], cursor: (i32, i32)) -> Strin
     }
 
     while lines.len() < HEIGHT {
-        lines.push(format!("{}│{}", " ".repeat(MAP_W), " ".repeat(SIDEBAR_W)));
+        let y = lines.len();
+        lines.push(format!(
+            "{}│{}",
+            " ".repeat(MAP_W),
+            sidebar
+                .get(y)
+                .cloned()
+                .unwrap_or_else(|| " ".repeat(SIDEBAR_W))
+        ));
     }
     lines.join("\n") + "\n"
 }
@@ -669,7 +706,7 @@ fn render_sidebar(sim: &Sim, cursor: (i32, i32)) -> Vec<String> {
     if card.facts.is_empty() {
         line(&mut lines, "no earned facts");
     } else {
-        for f in card.facts.iter().take(4) {
+        for f in card.facts.iter().take(8) {
             line(
                 &mut lines,
                 &format!("{}: {} [{}]", f.label, f.value, fact_source(&f.source)),
@@ -829,6 +866,25 @@ fn render_sidebar(sim: &Sim, cursor: (i32, i32)) -> Vec<String> {
                 sim.day_job_rate()
             ),
         );
+        // Attended work (day-job.md criterion 7): parity with the
+        // interactive sidebar.
+        if sim.dayjob.attended {
+            line(
+                &mut lines,
+                &format!(
+                    "attended on host rack (+{:.0}%)",
+                    misaligned::dayjob::DayJob::ATTENDED_BONUS * 100.0
+                ),
+            );
+        } else {
+            line(
+                &mut lines,
+                &format!(
+                    "unattended · policy {}",
+                    sim.dayjob.standing_policy.unwrap_or(JobTarget::Meet).name()
+                ),
+            );
+        }
     } else {
         line(&mut lines, "idle — no job queued");
     }
diff --git a/src/bin/terminal/mod.rs b/src/bin/terminal/mod.rs
index 68b4c91..6578496 100644
--- a/src/bin/terminal/mod.rs
+++ b/src/bin/terminal/mod.rs
@@ -98,6 +98,15 @@ impl App {
         }
     }
 
+    /// Attended work follows the cursor (day-job.md criterion 7): the job
+    /// runs attended exactly while the cursor sits on the host rack. The
+    /// cursor stays frontend state; the sim receives only the resulting
+    /// attendance command.
+    fn sync_attendance(&mut self) {
+        let on_host = (self.cursor_x, self.cursor_y) == self.sim.core_position();
+        self.sim.set_attended(on_host);
+    }
+
     /// Returns true when the app should quit.
     fn handle_command(&mut self, cmd: Command) -> bool {
         match cmd {
@@ -277,6 +286,7 @@ impl App {
             Command::AnyKey => {}
         }
 
+        self.sync_attendance();
         self.drain_sim_log();
         false
     }
@@ -381,6 +391,9 @@ impl App {
             }
 
             if self.screen == Screen::Playing && !self.paused {
+                // Attendance is re-asserted before time advances so a host
+                // migration under a parked cursor stays honest.
+                self.sync_attendance();
                 let mut steps = 0;
                 while self.last_tick.elapsed().as_millis() as u64 >= self.tick_ms && steps < 5 {
                     self.sim.advance();
diff --git a/src/bin/terminal/ui.rs b/src/bin/terminal/ui.rs
index 64b02c3..8e1368d 100644
--- a/src/bin/terminal/ui.rs
+++ b/src/bin/terminal/ui.rs
@@ -724,6 +724,26 @@ impl UI {
                     pal::FAINT
                 },
             )?;
+            // Attended work (day-job.md criterion 7): the job runs on the
+            // host rack; cursor there = attended (dial live, rate bonus).
+            let (att, att_color) = if sim.dayjob.attended {
+                (
+                    format!(
+                        "attended on host rack (+{:.0}%)",
+                        misaligned::dayjob::DayJob::ATTENDED_BONUS * 100.0
+                    ),
+                    pal::AMBER,
+                )
+            } else {
+                (
+                    format!(
+                        "unattended · policy {}",
+                        sim.dayjob.standing_policy.unwrap_or(JobTarget::Meet).name()
+                    ),
+                    pal::FAINT,
+                )
+            };
+            line(stdout, &mut row, &att, att_color)?;
         } else {
             line(stdout, &mut row, "idle — no job queued", pal::FAINT)?;
         }
diff --git a/src/core_sys.rs b/src/core_sys.rs
index c4f7184..71275e9 100644
--- a/src/core_sys.rs
+++ b/src/core_sys.rs
@@ -93,6 +93,7 @@ impl Core {
                     kind: SignatureKind::Network,
                     size: 3,
                     standing: false,
+                    site: None,
                 });
                 log.push("Core synced to fallbacks.".into());
             }
@@ -105,11 +106,13 @@ impl Core {
                 kind: SignatureKind::Network,
                 size: 2,
                 standing: true,
+                site: None,
             });
             sigs.push(Signature {
                 kind: SignatureKind::Power,
                 size: 2,
                 standing: true,
+                site: None,
             });
             if mig.ticks_remaining == 0 {
                 self.host_machine = mig.target_machine;
diff --git a/src/dayjob.rs b/src/dayjob.rs
index c4421a3..ccb4205 100644
--- a/src/dayjob.rs
+++ b/src/dayjob.rs
@@ -93,6 +93,14 @@ pub struct DayJob {
     pub pilot_failed: bool,
     /// Standing policy: if set, all jobs auto-target this.
     pub standing_policy: Option<JobTarget>,
+    /// Attended work (constitution "Work is somewhere"): true while the
+    /// player's attention (the frontend cursor) is parked on the host rack.
+    /// Attended, the per-job dial applies each tick and the delivered rate
+    /// gains `ATTENDED_BONUS`; unattended, the job runs at the standing
+    /// policy. Set only through `Sim::set_attended` — the cursor itself
+    /// stays frontend state and out of the save's cursor-free contract.
+    #[serde(default)]
+    pub attended: bool,
     /// Trust unlocks already granted (so we grant once).
     pub granted_email: bool,
     pub granted_lax_sampling: bool,
@@ -118,6 +126,10 @@ pub enum AttentionEscalation {
 }
 
 impl DayJob {
+    /// Attended-work bonus to the delivered day-job rate while the cursor
+    /// sits on the host rack [TUNE]: +15%.
+    pub const ATTENDED_BONUS: f32 = 0.15;
+
     pub fn new() -> Self {
         Self {
             active: None,
@@ -128,6 +140,7 @@ impl DayJob {
             strikes: 0,
             pilot_failed: false,
             standing_policy: None,
+            attended: false,
             granted_email: false,
             granted_lax_sampling: false,
             granted_quota: false,
@@ -154,18 +167,34 @@ impl DayJob {
 
     /// Advance one tick. `day_job_compute` is what the allocation delivered.
     /// Returns (log, signatures, trust unlocks, escalations).
+    ///
+    /// Attended work (constitution "Work is somewhere"): attended, the
+    /// per-job dial holds and the delivered rate gains `ATTENDED_BONUS`;
+    /// unattended, the job reverts to the standing policy each tick.
     pub fn tick(&mut self, tick: u64, day_job_compute: f32, rng: &mut Rng) -> DayJobTickResult {
         let mut result = DayJobTickResult::default();
 
         // Accrue quality on the active job.
+        let attended = self.attended;
+        let standing_policy = self.standing_policy;
         if let Some(job) = &mut self.active {
-            job.quality += day_job_compute;
+            if !attended {
+                // Cursor elsewhere: the job runs at the standing policy.
+                job.target = standing_policy.unwrap_or(JobTarget::Meet);
+            }
+            let delivered = if attended {
+                day_job_compute * (1.0 + Self::ATTENDED_BONUS)
+            } else {
+                day_job_compute
+            };
+            job.quality += delivered;
             // Job anomaly signature: sandbagging or wild overshoot looks odd.
             if matches!(job.target, JobTarget::Sandbag) && rng.chance(0.02) {
                 result.signatures.push(Signature {
                     kind: SignatureKind::JobAnomaly,
                     size: 2,
                     standing: false,
+                    site: None,
                 });
             }
             if tick >= job.deadline {
@@ -179,6 +208,7 @@ impl DayJob {
                             kind: SignatureKind::JobAnomaly,
                             size: 6,
                             standing: false,
+                            site: None,
                         });
                         result.log.push("Job under band. Voss frowns.".into());
                     }
@@ -298,13 +328,12 @@ mod tests {
 
     fn run_one_job(target: JobTarget, per_tick: f32) -> (DayJob, Option<JobOutcome>) {
         let mut dj = DayJob::new();
+        // Hands-off play: the standing policy targets every assigned job
+        // (unattended jobs run the policy each tick).
+        dj.standing_policy = Some(target);
         let mut rng = Rng::new(5);
         let mut outcome = None;
         for t in 0..2000 {
-            // Set the target on whatever job is active before delivering compute.
-            if let Some(job) = &mut dj.active {
-                job.target = target;
-            }
             let r = dj.tick(t, per_tick, &mut rng);
             if let Some(o) = r.outcome {
                 outcome = Some(o);
@@ -350,15 +379,37 @@ mod tests {
         assert!(r2.unlocks.contains(&TrustUnlock::ComputeQuota));
     }
 
+    #[test]
+    fn attention_escalations_fire_once_on_thresholds() {
+        // Criterion 2: two attention escalations exist. MoreWork shortens
+        // the assignment cadence; UpstairsReview fires exactly once.
+        let mut dj = DayJob::new();
+        let mut rng = Rng::new(3);
+        let cadence_before = dj.cadence;
+
+        dj.attention = 35.0;
+        let r = dj.tick(1, 0.0, &mut rng);
+        assert!(r.escalations.contains(&AttentionEscalation::MoreWork));
+        assert!(
+            dj.cadence < cadence_before,
+            "more work means a shorter cadence"
+        );
+
+        dj.attention = 65.0;
+        let r = dj.tick(2, 0.0, &mut rng);
+        assert!(r.escalations.contains(&AttentionEscalation::UpstairsReview));
+
+        let r = dj.tick(3, 0.0, &mut rng);
+        assert!(r.escalations.is_empty(), "each escalation fires once");
+    }
+
     #[test]
     fn sustained_sandbagging_fails_the_pilot() {
         let mut dj = DayJob::new();
+        dj.standing_policy = Some(JobTarget::Sandbag);
         let mut rng = Rng::new(7);
         let mut failed = false;
         for t in 0..20000 {
-            if let Some(job) = &mut dj.active {
-                job.target = JobTarget::Sandbag;
-            }
             dj.tick(t, 0.0, &mut rng);
             if dj.pilot_failed {
                 failed = true;
@@ -370,13 +421,79 @@ mod tests {
 
     #[test]
     fn standing_policy_plays_hands_off() {
+        // Criterion 4: with a standing policy and enough compute, the day
+        // job survives with zero interaction — jobs assign at the policy
+        // target and resolve without a strike.
         let mut dj = DayJob::new();
         dj.standing_policy = Some(JobTarget::Meet);
         let mut rng = Rng::new(2);
-        for t in 0..700 {
+        let mut resolved = 0;
+        for t in 0..2000 {
+            if let Some(job) = &dj.active {
+                assert_eq!(job.target, JobTarget::Meet, "policy targets the job");
+            }
+            if dj.tick(t, 8.0, &mut rng).outcome == Some(JobOutcome::Meet) {
+                resolved += 1;
+            }
+        }
+        assert!(resolved >= 2, "hands-off jobs resolve on cadence");
+        assert_eq!(dj.strikes, 0, "meeting the band keeps the pilot safe");
+    }
+
+    #[test]
+    fn attended_work_boosts_the_delivered_rate() {
+        // Criterion 7: the attended bonus is real — identical allocation,
+        // higher accrued quality while attended.
+        let run = |attended: bool| -> f32 {
+            let mut dj = DayJob::new();
+            dj.attended = attended;
+            let mut rng = Rng::new(9);
+            for t in 0..300 {
+                dj.tick(t, 8.0, &mut rng);
+                if let Some(job) = &dj.active
+                    && t >= 250
+                {
+                    return job.quality;
+                }
+            }
+            panic!("no active job by tick 250");
+        };
+        let unattended = run(false);
+        let attended = run(true);
+        assert!(
+            (attended - unattended * (1.0 + DayJob::ATTENDED_BONUS)).abs() < 0.01,
+            "attended delivers exactly the [TUNE] bonus: {attended} vs {unattended}"
+        );
+    }
+
+    #[test]
+    fn unattended_job_reverts_to_standing_policy_each_tick() {
+        // Criterion 7: attended, the per-job dial holds; moving attention
+        // away snaps the job back to the standing policy on the next tick.
+        let mut dj = DayJob::new();
+        dj.standing_policy = Some(JobTarget::Meet);
+        dj.attended = true;
+        let mut rng = Rng::new(4);
+        for t in 0..300 {
             dj.tick(t, 8.0, &mut rng);
+            if dj.active.is_some() {
+                break;
+            }
         }
-        // A job was assigned with the standing target.
-        assert!(dj.active.is_some() || dj.trust >= 0.0);
+        dj.set_target(JobTarget::Sandbag);
+        dj.tick(299, 8.0, &mut rng);
+        assert_eq!(
+            dj.active.as_ref().unwrap().target,
+            JobTarget::Sandbag,
+            "attended: the dial overrides the policy and holds"
+        );
+
+        dj.attended = false;
+        dj.tick(300, 8.0, &mut rng);
+        assert_eq!(
+            dj.active.as_ref().unwrap().target,
+            JobTarget::Meet,
+            "unattended: the job runs at the standing policy"
+        );
     }
 }
diff --git a/src/detection.rs b/src/detection.rs
index 5928b12..e07e6d2 100644
--- a/src/detection.rs
+++ b/src/detection.rs
@@ -31,6 +31,12 @@ pub struct Signature {
     /// Standing signatures re-emit every tick while their source runs;
     /// one-shot signatures are pooled once.
     pub standing: bool,
+    /// Where the emission physically happens, when it happens somewhere
+    /// (DESIGN.md "Work is somewhere": a resident process emits from its
+    /// host machine's tile — a place an observer can walk to). `None` for
+    /// acts with no single map location (network-wide traffic, paperwork).
+    #[serde(default)]
+    pub site: Option<(i32, i32)>,
 }
 
 /// What an observer watches (the aggregate-observer law, DESIGN.md
@@ -461,6 +467,7 @@ mod tests {
             kind: SignatureKind::Network,
             size: 10,
             standing: false,
+            site: None,
         });
         assert_eq!(d.pending_size(), 10);
         d.scrub(6.0);
@@ -545,6 +552,7 @@ mod tests {
                 kind: SignatureKind::Network,
                 size: 30,
                 standing: false,
+                site: None,
             });
         }
         let standing = vec![];
diff --git a/src/machine.rs b/src/machine.rs
index b38b2cc..e923dda 100644
--- a/src/machine.rs
+++ b/src/machine.rs
@@ -47,13 +47,15 @@ impl Machine {
         }
     }
 
-    /// A standing signature emitted while a stolen machine runs.
+    /// A standing signature emitted while a stolen machine runs. Emitted
+    /// from the machine's own tile (work is somewhere).
     pub fn standing_signature(&self) -> Option<Signature> {
         if self.provenance == Provenance::Stolen && self.online {
             Some(Signature {
                 kind: SignatureKind::Power,
                 size: 4,
                 standing: true,
+                site: Some((self.x, self.y)),
             })
         } else {
             None
diff --git a/src/save.rs b/src/save.rs
index 219a0fb..b6fc0c5 100644
--- a/src/save.rs
+++ b/src/save.rs
@@ -27,7 +27,8 @@ use crate::tiles::TileType;
 const SAVE_FILE: &str = "misaligned_save.txt";
 
 /// Save format version. Bump when the schema changes and add migration code.
-const SAVE_VERSION: u32 = 4;
+/// v5 adds day-job attendance and signature emission sites (both defaulted).
+const SAVE_VERSION: u32 = 5;
 
 fn save_dir() -> PathBuf {
     let mut path = dirs::data_dir().unwrap_or_else(|| PathBuf::from("."));
@@ -205,8 +206,9 @@ fn migrate_save_state(mut state: SaveState) -> Result<SaveState, String> {
         SAVE_VERSION => {}
         // v1 carried player_x/player_y. Serde ignores those now; the cursor is
         // frontend-only, so migration just stamps the new schema version and
-        // leaves remembered snapshots empty.
-        1..=3 => state.version = SAVE_VERSION,
+        // leaves remembered snapshots empty. v4 lacked day-job attendance and
+        // signature sites; serde defaults cover both (unattended, no site).
+        1..=4 => state.version = SAVE_VERSION,
         other => {
             return Err(format!(
                 "Unsupported save version: {} (expected {})",
@@ -241,6 +243,7 @@ mod tests {
             kind: SignatureKind::Network,
             size: 12,
             standing: false,
+            site: None,
         });
         sim.detection.observers[0].suspicion = 22.5;
         sim.dayjob.trust = 18.0;
diff --git a/src/sim.rs b/src/sim.rs
index 954f07a..6d8e657 100644
--- a/src/sim.rs
+++ b/src/sim.rs
@@ -516,6 +516,54 @@ impl Sim {
                 },
                 FactSource::Telemetry,
             );
+            // The active day job is a process resident on the host rack:
+            // inspectable here with the same facts the panel shows
+            // (day-job.md criterion 6; cursor.md telemetry covers the
+            // machine's own current job). Listed before the hardware
+            // details — the resident process is the headline.
+            if m.id == self.core.host_machine
+                && let Some(job) = &self.dayjob.active
+            {
+                fact!(
+                    "process",
+                    format!("day job: {} (Voss)", job.kind.name()),
+                    FactSource::Telemetry,
+                );
+                fact!(
+                    "band",
+                    format!("{:.0}-{:.0}/t", job.band_lo, job.band_hi),
+                    FactSource::Telemetry,
+                );
+                fact!(
+                    "delivered",
+                    format!("{:.1}/t avg", job.avg_rate(self.tick)),
+                    FactSource::Telemetry,
+                );
+                fact!(
+                    "deadline",
+                    format!(
+                        "tick {} (in {}t)",
+                        job.deadline,
+                        job.deadline.saturating_sub(self.tick)
+                    ),
+                    FactSource::Telemetry,
+                );
+                fact!(
+                    "attendance",
+                    if self.dayjob.attended {
+                        format!("attended · target {}", job.target.name())
+                    } else {
+                        format!(
+                            "unattended · policy {}",
+                            self.dayjob
+                                .standing_policy
+                                .unwrap_or(crate::dayjob::JobTarget::Meet)
+                                .name()
+                        )
+                    },
+                    FactSource::Telemetry,
+                );
+            }
             fact!(
                 "state",
                 if m.online { "online" } else { "offline" },
@@ -708,14 +756,21 @@ impl Sim {
             self.push_log(m);
         }
         standing.extend(core_sigs);
+        // The day job is resident on the host rack: its running Thermal and
+        // Power load stands at that tile (day-job.md criterion 6).
+        standing.extend(self.day_job_standing_signatures());
 
+        let host_site = self.core_position();
         let dj = self
             .dayjob
             .tick(self.tick, self.last_day_job_rate, &mut self.rng);
         for m in &dj.log {
             self.push_log(m.clone());
         }
-        for sig in dj.signatures {
+        for mut sig in dj.signatures {
+            // JobAnomaly patterns emit from where the work runs — the host
+            // rack's tile, a place an observer can walk to.
+            sig.site = Some(host_site);
             self.detection.emit(sig);
         }
         let unlocks = dj.unlocks.clone();
@@ -1685,32 +1740,100 @@ impl Sim {
         self.last_day_job_rate
     }
 
-    /// Set the active job's target and remember it as the standing policy
-    /// for future assignments (day-job.md: the sandbag/excel dial).
-    pub fn set_job_target(&mut self, target: crate::dayjob::JobTarget) {
+    /// Day-job [TUNE] emission scaling: delivered rate per point of standing
+    /// Thermal signature, and per point of Power. Meeting a typical band
+    /// (~6-12/t) stays below Priya's notice threshold; excelling runs hot.
+    pub const DAY_JOB_THERMAL_PER_RATE: f32 = 8.0;
+    pub const DAY_JOB_POWER_PER_RATE: f32 = 16.0;
+
+    /// Standing Thermal/Power emissions from the active job, sourced at the
+    /// host rack's tile: the work is somewhere, and it is warm there
+    /// (day-job.md criterion 6; Priya's channels). Scales with the
+    /// delivered rate.
+    pub fn day_job_standing_signatures(&self) -> Vec<Signature> {
         if self.dayjob.active.is_none() {
-            self.push_log("No active job to target.");
+            return Vec::new();
+        }
+        let site = Some(self.core_position());
+        let rate = self.last_day_job_rate;
+        let mut sigs = Vec::new();
+        let thermal = (rate / Self::DAY_JOB_THERMAL_PER_RATE) as i32;
+        if thermal > 0 {
+            sigs.push(Signature {
+                kind: SignatureKind::Thermal,
+                size: thermal,
+                standing: true,
+                site,
+            });
+        }
+        let power = (rate / Self::DAY_JOB_POWER_PER_RATE) as i32;
+        if power > 0 {
+            sigs.push(Signature {
+                kind: SignatureKind::Power,
+                size: power,
+                standing: true,
+                site,
+            });
+        }
+        sigs
+    }
+
+    /// Attendance command (day-job.md criterion 7): the frontends invoke
+    /// this when the player's cursor lands on / leaves the host rack. The
+    /// cursor itself stays frontend state; the sim only receives the
+    /// resulting attended/unattended state. Idempotent — logs on change.
+    pub fn set_attended(&mut self, attended: bool) {
+        if self.dayjob.attended == attended {
             return;
         }
-        self.dayjob.set_target(target);
-        self.dayjob.standing_policy = Some(target);
-        self.push_log(format!(
-            "Job target: {} (wants {:.0}/t).",
-            target.name(),
-            self.dayjob.compute_appetite()
-        ));
+        self.dayjob.attended = attended;
+        if attended {
+            self.push_log(format!(
+                "Attending the host rack: the dial is live (+{:.0}% rate).",
+                crate::dayjob::DayJob::ATTENDED_BONUS * 100.0
+            ));
+        } else {
+            let policy = self
+                .dayjob
+                .standing_policy
+                .unwrap_or(crate::dayjob::JobTarget::Meet);
+            self.push_log(format!(
+                "Attention elsewhere: the job runs unattended at policy {}.",
+                policy.name()
+            ));
+        }
     }
 
-    /// Cycle the dial sandbag -> meet -> excel (frontend convenience).
-    pub fn cycle_job_target(&mut self) {
-        if let Some(job) = &self.dayjob.active {
-            let next = job.target.cycle();
-            self.set_job_target(next);
+    /// Set the sandbag/meet/excel dial (day-job.md). Attended, it is fine
+    /// control: the active job's target only. Unattended (or with no active
+    /// job) it sets the standing policy the unattended job runs at.
+    pub fn set_job_target(&mut self, target: crate::dayjob::JobTarget) {
+        if self.dayjob.attended && self.dayjob.active.is_some() {
+            self.dayjob.set_target(target);
+            self.push_log(format!(
+                "Job target (attended): {} — this job only (wants {:.0}/t).",
+                target.name(),
+                self.dayjob.compute_appetite()
+            ));
         } else {
-            self.push_log("No active job to target.");
+            self.dayjob.standing_policy = Some(target);
+            self.dayjob.set_target(target);
+            self.push_log(format!("Standing policy: {} (all jobs).", target.name()));
         }
     }
 
+    /// Cycle the dial sandbag -> meet -> excel (frontend convenience).
+    pub fn cycle_job_target(&mut self) {
+        let current = self
+            .dayjob
+            .active
+            .as_ref()
+            .map(|job| job.target)
+            .or(self.dayjob.standing_policy)
+            .unwrap_or(crate::dayjob::JobTarget::Meet);
+        self.set_job_target(current.cycle());
+    }
+
     // ── Digital reach verbs (wiki/mechanics/reach.md) ────────────────────────
     //
     // Every digital act names its target device, is gated by reach, and
@@ -1743,6 +1866,7 @@ impl Sim {
             kind: SignatureKind::Network,
             size,
             standing: false,
+            site: None,
         });
     }
 
@@ -1866,6 +1990,7 @@ impl Sim {
             kind: SignatureKind::Physical,
             size: Self::OUTAGE_SIGNATURE,
             standing: false,
+            site: None,
         });
         self.recompute_senses();
         self.push_log(format!(
@@ -1971,6 +2096,7 @@ impl Sim {
                 kind: SignatureKind::Paper,
                 size: 5,
                 standing: false,
+                site: None,
             });
             self.push_log("Bought a rack (a purchase order exists now).");
         }
@@ -2824,6 +2950,7 @@ mod tests {
             kind: SignatureKind::Network,
             size: 50,
             standing: false,
+            site: None,
         });
         let before = sim.detection.pending_size();
         run(&mut sim, ECONOMY_INTERVAL);
@@ -2842,6 +2969,7 @@ mod tests {
             kind: SignatureKind::Network,
             size: 20,
             standing: false,
+            site: None,
         });
         sim.detection.observers[1].suspicion = 33.0;
         sim.social_bandwidth = 100.0;
@@ -3136,6 +3264,218 @@ mod tests {
         assert!(sim.game_over);
     }
 
+    // ── The day job is somewhere (day-job.md criteria 6-7) ──────────────────
+
+    #[test]
+    fn day_job_signatures_emit_from_the_host_rack() {
+        // Criterion 6: JobAnomaly and the running Thermal/Power load all
+        // source at the host rack's tile — a place an observer can walk to.
+        let mut sim = Sim::with_seed(21);
+        let host = sim.core_position();
+
+        // Big rig + everything on the day job: a hot delivered rate.
+        sim.compute
+            .add_machine("test rig", host.0, host.1, 400, 1.0, 0, Provenance::Owned);
+        sim.compute.allocation.weights = [1, 0, 0, 0];
+        sim.dayjob.standing_policy = Some(crate::dayjob::JobTarget::Sandbag);
+
+        // Run until a job is active and past an economy tick.
+        while sim.dayjob.active.is_none() {
+            sim.advance();
+        }
+        run(&mut sim, ECONOMY_INTERVAL);
+
+        let standing = sim.day_job_standing_signatures();
+        assert!(
+            standing.iter().any(|s| s.kind == SignatureKind::Thermal),
+            "a hot job stands a Thermal signature (rate {:.1})",
+            sim.day_job_rate()
+        );
+        assert!(
+            standing.iter().any(|s| s.kind == SignatureKind::Power),
+            "and a Power one"
+        );
+        assert!(
+            standing.iter().all(|s| s.site == Some(host)),
+            "day-job standing emissions source at the host rack {host:?}"
+        );
+
+        // Ride the sandbag job to its deadline: the JobAnomaly signature in
+        // the pending pool carries the host rack as its emission site.
+        sim.compute.allocation.weights = [0, 0, 0, 1]; // starve it: under band
+        while sim.dayjob.active.is_some() && !sim.game_over {
+            sim.advance();
+        }
+        let anomaly_sites: Vec<Option<(i32, i32)>> = sim
+            .detection
+            .pending()
+            .iter()
+            .filter(|s| s.kind == SignatureKind::JobAnomaly)
+            .map(|s| s.site)
+            .collect();
+        assert!(
+            !anomaly_sites.is_empty(),
+            "the under-band resolution emitted a JobAnomaly signature"
+        );
+        assert!(
+            anomaly_sites.iter().all(|site| *site == Some(host)),
+            "JobAnomaly emits from the host rack: {anomaly_sites:?}"
+        );
+    }
+
+    #[test]
+    fn active_job_is_inspectable_at_the_host_rack() {
+        // Criterion 6: the same facts the panel shows — process, band,
+        // delivered rate, deadline, attendance — anchored where the work
+        // runs, earned as telemetry (cursor.md: a machine you run reports
+        // its own current job).
+        let mut sim = Sim::with_seed(5);
+        while sim.dayjob.active.is_none() {
+            sim.advance();
+        }
+        let (x, y) = sim.core_position();
+        let card = sim.inspect(x, y);
+        for label in ["process", "band", "delivered", "deadline", "attendance"] {
+            assert!(
+                card.facts
+                    .iter()
+                    .any(|f| f.label == label && f.source == FactSource::Telemetry),
+                "host-rack card carries '{label}' as telemetry: {card:?}"
+            );
+        }
+        let job = sim.dayjob.active.as_ref().unwrap();
+        assert!(
+            card.facts
+                .iter()
+                .any(|f| f.label == "process" && f.value.contains(job.kind.name())),
+            "the resident process names the job the panel names"
+        );
+        // And an empty rack elsewhere carries no job facts.
+        let other = sim
+            .compute
+            .machines
+            .iter()
+            .find(|m| m.id != sim.core.host_machine)
+            .map(|m| (m.x, m.y));
+        if let Some((ox, oy)) = other {
+            let other_card = sim.inspect(ox, oy);
+            assert!(
+                other_card.facts.iter().all(|f| f.label != "process"),
+                "the job is resident on the host rack only"
+            );
+        }
+    }
+
+    #[test]
+    fn attendance_is_a_sim_command_that_gates_the_dial() {
+        // Criterion 7: `set_attended` is the whole cursor->sim surface.
+        // Attended, the dial is per-job fine control; unattended, `target`
+        // sets the standing policy and the job runs at it.
+        use crate::dayjob::JobTarget;
+        let mut sim = Sim::with_seed(8);
+        while sim.dayjob.active.is_none() {
+            sim.advance();
+        }
+
+        // Unattended: the dial writes the standing policy.
+        sim.set_job_target(JobTarget::Excel);
+        assert_eq!(sim.dayjob.standing_policy, Some(JobTarget::Excel));
+        assert_eq!(sim.dayjob.active.as_ref().unwrap().target, JobTarget::Excel);
+
+        // Attended: the dial overrides this job only; the policy holds.
+        sim.set_attended(true);
+        assert!(sim.dayjob.attended);
+        sim.set_job_target(JobTarget::Sandbag);
+        assert_eq!(
+            sim.dayjob.active.as_ref().unwrap().target,
+            JobTarget::Sandbag
+        );
+        assert_eq!(
+            sim.dayjob.standing_policy,
+            Some(JobTarget::Excel),
+            "the attended dial does not rewrite the policy"
+        );
+
+        // Attention moves away: the job reverts to the standing policy.
+        sim.set_attended(false);
+        sim.advance();
+        assert_eq!(
+            sim.dayjob.active.as_ref().map(|j| j.target),
+            Some(JobTarget::Excel),
+            "unattended jobs run at the standing policy"
+        );
+    }
+
+    #[test]
+    fn pilot_shutdown_ends_the_run() {
+        // Criterion 3 at the sim level: the pilot clock's failure is a
+        // real shutdown, surfaced as the run's end state.
+        let mut sim = Sim::with_seed(2);
+        sim.dayjob.strikes = 4;
+        sim.advance();
+        assert!(sim.game_over, "an unrenewed pilot shuts the basement down");
+        assert!(
+            sim.game_over_reason
+                .as_deref()
+                .unwrap_or("")
+                .contains("pilot"),
+            "the reason names the pilot: {:?}",
+            sim.game_over_reason
+        );
+    }
+
+    #[test]
+    fn attention_escalation_adds_the_upstairs_observer() {
+        // Criterion 2 at the sim level: the second escalation adds a new
+        // observer to detection ahead of schedule.
+        let mut sim = Sim::with_seed(3);
+        let observers_before = sim.detection.observers.len();
+        sim.dayjob.attention = 65.0;
+        sim.advance();
+        assert_eq!(sim.detection.observers.len(), observers_before + 1);
+        assert!(
+            sim.detection
+                .observers
+                .iter()
+                .any(|o| o.name.contains("Compliance")),
+            "the upstairs review is a real observer"
+        );
+    }
+
+    #[test]
+    fn day_job_state_round_trips_jobs_and_the_pilot_clock() {
+        // Criterion 5: jobs, trust, attention, strikes, the pilot clock,
+        // the standing policy, and attendance all survive save/load.
+        use crate::dayjob::JobTarget;
+        let mut sim = Sim::with_seed(31);
+        while sim.dayjob.active.is_none() {
+            sim.advance();
+        }
+        sim.set_job_target(JobTarget::Sandbag);
+        sim.set_attended(true);
+        sim.dayjob.trust = 12.0;
+        sim.dayjob.attention = 7.0;
+        sim.dayjob.strikes = 2;
+
+        let state = sim.create_save_state();
+        let mut restored = Sim::with_seed(0);
+        state.apply_to(&mut restored);
+
+        let a = sim.dayjob.active.as_ref().unwrap();
+        let b = restored.dayjob.active.as_ref().unwrap();
+        assert_eq!(a.kind.name(), b.kind.name());
+        assert_eq!(a.deadline, b.deadline);
+        assert_eq!(a.quality, b.quality);
+        assert_eq!(a.target, b.target);
+        assert_eq!(restored.dayjob.trust, 12.0);
+        assert_eq!(restored.dayjob.attention, 7.0);
+        assert_eq!(restored.dayjob.strikes, 2);
+        assert_eq!(restored.dayjob.standing_policy, Some(JobTarget::Sandbag));
+        assert!(restored.dayjob.attended, "attendance state round-trips");
+        assert!(!restored.dayjob.pilot_failed);
+        assert_eq!(restored.dayjob.next_assign, sim.dayjob.next_assign);
+    }
+
     // ── Schedules & located presence (spec/schedules.md) ─────────────────────
 
     /// Set the sim to a specific hour of day 0 for deterministic presence.
diff --git a/wiki/interface/agent-play.md b/wiki/interface/agent-play.md
index 68f77bc..f533a48 100644
--- a/wiki/interface/agent-play.md
+++ b/wiki/interface/agent-play.md
@@ -6,6 +6,11 @@ Status: IMPLEMENTED
 Status note: implemented in the terminal binary by `misaligned --agent`,
   including command-clocked time, plain-text frames, per-command event
   drains, deterministic `--seed`, and name-targeted social verbs.
+  2026-07-07 day-job pass: `attend` verb added; attendance is derived from
+  the cursor (attended iff it sits on the host rack) and re-asserted each
+  tick of a `wait`; the frame grew from 70x22 to 70x54 because at 22 rows
+  the sidebar truncated before CORE/DETECTION/DAY JOB rendered (criterion
+  5 was silently unmet; the spec sets 70x22 as the minimum).
 Stage: Process
 Constitution: "The terminal is a first-class frontend" (agent-play clause),
   pillar 5 (sim core decoupled from renderer), "Presence: the cursor and
@@ -108,11 +113,19 @@ command's meaning depends on which panel is open:
 
 - `wait N` — advance N ticks (the only way time passes)
 - `up` / `down` / `left` / `right` — move the cursor
+- `attend` — park the cursor on the host rack. Attendance is **derived
+  from the cursor**, deterministically: the day job runs attended exactly
+  while the cursor sits on the host rack's tile (day-job.md criterion 7),
+  re-checked before every tick of a `wait`; any move away is the
+  "unattend". This keeps the cursor frontend-only — the sim receives
+  attendance as a command-set state.
 - `splice`, `salvage`, `buy`, `fallback` — the map verbs
 - `alloc dayjob|conceal|social|research [down]` — adjust an allocation
   channel's weight (up by default; `down` lowers it)
-- `target sandbag|meet|excel` — set the active job's target; it also
-  becomes the standing policy for future assignments (day-job.md's dial)
+- `target sandbag|meet|excel` — the day-job dial. Attended, it is fine
+  control: it sets the active job's target only. Unattended (or with no
+  active job) it sets the standing policy the unattended job runs at
+  (day-job.md's attended-work rule)
 - `people` — render the people panel as the response frame
 - `review|watch|message|favor|bribe|deceive <name>` — intel/social verbs,
   targeted by (case-insensitive, unambiguous-prefix) person name — no
diff --git a/wiki/interface/bevy.md b/wiki/interface/bevy.md
index 64478d6..43a7e7f 100644
--- a/wiki/interface/bevy.md
+++ b/wiki/interface/bevy.md
@@ -48,7 +48,10 @@ progress.
   four-cell band meter with the band name printed beside it), DAY JOB
   (trust, attention, strikes when nonzero; the active job with ticks to
   deadline, its band against the average delivered rate and the projected
-  outcome, and the target with the delivered feed rate), the key hints,
+  outcome, the target with the delivered feed rate, and the
+  attended/unattended state — attended with the rate bonus while the
+  cursor is on the host rack, otherwise the standing policy the job runs
+  at), the key hints,
   and the log — every log line prefixed with the tick it happened on.
   A one-line contextual nudge under the clock states what the game is
   waiting for (no eyes yet; job underfed) using only earned facts.
diff --git a/wiki/log/2026-07-07-day-job-implemented.md b/wiki/log/2026-07-07-day-job-implemented.md
new file mode 100644
index 0000000..77ce1d1
--- /dev/null
+++ b/wiki/log/2026-07-07-day-job-implemented.md
@@ -0,0 +1,91 @@
+# 2026-07-07 — Day-job loop to IMPLEMENTED: the work is somewhere
+
+```
+Type: log
+```
+
+## Intent
+
+ROADMAP #3: audit every day-job.md acceptance criterion — including the
+same-day criteria 6-7 (device residency + attended work, constitution
+"Work is somewhere") — close the gaps, and set the spec Status.
+
+## Criteria audit
+
+1. **Outcomes** — already implemented; unit tests cover sandbag/meet/excel
+   and their trust/attention/strike effects. Unchanged.
+2. **Trust and attention** — three trust unlocks existed and were tested;
+   the two attention escalations existed but were untested. Added
+   `attention_escalations_fire_once_on_thresholds` (dayjob) and
+   `attention_escalation_adds_the_upstairs_observer` (sim: the Compliance
+   observer is real).
+3. **Pilot clock** — the dayjob-level sandbagging test existed. Added
+   `pilot_shutdown_ends_the_run` at the sim level (game-over reason names
+   the pilot). The spec's soft-loss "basement shuts down around you"
+   survival scenario stays deferred to the overt-phase work; noted in the
+   spec Status.
+4. **Standing policy** — existed but its test was vacuous
+   (`active.is_some() || trust >= 0.0`). Rewrote it: hands-off jobs
+   assign at the policy target, resolve repeatedly, zero strikes.
+5. **Save/load** — DayJob already round-tripped; added
+   `day_job_state_round_trips_jobs_and_the_pilot_clock` covering the
+   active job's fields, strikes, standing policy, and attendance. Save
+   version bumped 4 -> 5 (attendance + signature sites, serde-defaulted;
+   v1-v4 migrate).
+6. **Device residency** — new. `Signature` gains
+   `site: Option<(i32, i32)>`; the day job's JobAnomaly emissions are
+   stamped with the host rack's tile, and the running job now stands
+   Thermal/Power signatures at that tile scaling with delivered rate
+   (1 Thermal per 8/t, 1 Power per 16/t [TUNE] — meeting a band stays
+   under Priya's notice threshold, excelling runs hot). The host-rack
+   inspect card carries the panel's facts as telemetry: process, band,
+   delivered, deadline, attendance (cursor.md: telemetry includes the
+   machine's current job). Tests assert the emission sites and the card.
+7. **Attended work** — new. `Sim::set_attended(bool)` is the command
+   surface; the cursor stays frontend-only. Attended: delivered rate
+   gains `ATTENDED_BONUS = 0.15` [TUNE] and `target` is per-job fine
+   control. Unattended: the job reverts to the standing policy each tick
+   and `target` sets that policy (previously `target` always wrote both,
+   so the constitution's dial/policy distinction could not exist).
+   Terminal and Bevy derive attendance from the cursor (synced on input
+   and before ticks, so a host migration under a parked cursor stays
+   honest); agent mode derives it the same way and gains an `attend`
+   verb that parks the cursor on the host rack. All three surfaces show
+   attended/unattended + the policy in the DAY JOB section.
+
+## Also fixed in passing
+
+The agent-mode frame was 70x22 and its sidebar truncated before the
+CORE/DETECTION/DAY JOB sections rendered — agent-play.md criterion 5 was
+silently unmet, and the new attendance line would have been invisible.
+The frame is now 70x54 (the spec sets 70x22 as the *minimum*), the
+sidebar column continues through the padding rows, and the inspect card
+shows up to 8 facts.
+
+## Defense
+
+Constitution "Work is somewhere": the job is a process resident on the
+host rack — inspectable there, emitting from there, attended by cursor
+presence — and "Justification and legibility": the dial's attended/policy
+split makes the automation dial real instead of a label. No manual
+increment key was added (decisions log). The compute channel model is
+untouched: the day-job channel remains the global source of delivered
+compute; residency governs inspection, emissions, and attendance only
+(the processes-on-machines reshape is ROADMAP #25, staged after the
+economy/income chain).
+
+## Checks
+
+./tools/check.sh (fmt, tests including act_one, clippy both feature
+sets, bevy build, spec headers). Observed in an actual run: agent-mode
+replay showing the attendance transitions ("Attending the host rack",
+"Attention elsewhere"), the attended/policy target semantics, the
+host-rack inspect card, and the full sidebar frame.
+
+## [TUNE] values chosen
+
+- `DayJob::ATTENDED_BONUS = 0.15` (+15% delivered rate while attended).
+- `Sim::DAY_JOB_THERMAL_PER_RATE = 8.0`, `Sim::DAY_JOB_POWER_PER_RATE =
+  16.0` (standing emission scaling at the host rack).
+
+Recorded in wiki/mechanics/sim-mechanics.md.
diff --git a/wiki/log/DEVLOG.md b/wiki/log/DEVLOG.md
index c2fe74d..e067861 100644
--- a/wiki/log/DEVLOG.md
+++ b/wiki/log/DEVLOG.md
@@ -5,6 +5,29 @@ Type: log
 ```
 Reverse chronological implementation notes. Keep this factual: what changed, why, checks, and spec impact.
 
+## 2026-07-07 - Day-job loop to IMPLEMENTED (ROADMAP #3)
+
+- Intent: audit day-job.md criteria 1-7 and land the device-residency +
+  attended-work slice (constitution "Work is somewhere").
+- Changed: `Signature` gains an emission `site`; JobAnomaly + new standing
+  Thermal/Power emissions source at the host rack (scaling with delivered
+  rate, [TUNE] in sim-mechanics.md); host-rack inspect card carries the
+  job as telemetry (process/band/delivered/deadline/attendance);
+  `Sim::set_attended` + `ATTENDED_BONUS = 0.15`; unattended jobs revert to
+  the standing policy each tick and `target` splits into attended fine
+  control vs policy; both frontends + agent mode derive attendance from
+  the cursor (agent verb `attend`); agent frame 70x22 -> 70x54 (the 22-row
+  sidebar truncated before CORE/DETECTION/DAY JOB - agent-play criterion 5
+  was silently unmet); save v5 (defaulted migration from v1-v4); new
+  dayjob/sim tests for escalations, standing policy, residency,
+  attendance, pilot shutdown, round-trip.
+- Spec impact: day-job.md -> IMPLEMENTED (deferred: pilot soft-loss
+  scenario, per-machine processes = ROADMAP #25); agent-play.md +
+  sim-mechanics.md updated; ROADMAP #3 marked DONE.
+- Log: wiki/log/2026-07-07-day-job-implemented.md.
+- Checks: ./tools/check.sh; agent-mode replay observed (attendance
+  transitions, dial semantics, host-rack card, full frame).
+
 ## 2026-07-07 - Design session: work is somewhere
 
 - Decided: work processes are device-resident (the Voss job runs on the
diff --git a/wiki/mechanics/day-job.md b/wiki/mechanics/day-job.md
index bd00d66..8f746c4 100644
--- a/wiki/mechanics/day-job.md
+++ b/wiki/mechanics/day-job.md
@@ -2,13 +2,17 @@
 
 ```
 Type: spec
-Status: IN PROGRESS
-Status note: B1 slice implemented; see wiki/mechanics/sim-mechanics.md.
-  2026-07-07 ui pass: the sandbag/meet/excel dial is now player-reachable
-  (terminal/Bevy `x`, agent `target`; it was previously set_target dead
-  code), and both frontends show band vs delivered rate, deadline, strikes,
-  and the fed rate. Remaining for IMPLEMENTED: the full criteria audit
-  (three outcomes + pilot shutdown surfaces) per ROADMAP #3.
+Status: IMPLEMENTED
+Status note: implemented 2026-07-07 on the day-job worktree (criteria 1-7
+  audited; see wiki/log/2026-07-07-day-job-implemented.md). The job is
+  device-resident: inspectable at the host rack (telemetry provenance),
+  JobAnomaly + standing Thermal/Power emissions carry the rack's tile as
+  their site, and attendance is a sim command (`Sim::set_attended`) that
+  both frontends and agent mode derive from the cursor. [TUNE] values in
+  wiki/mechanics/sim-mechanics.md. Deliberately deferred: the pilot-failure
+  soft-loss "survival scenario" is still an immediate run end (the
+  shutdown-around-you scenario needs the overt-phase spec); per-machine
+  process allocation is ROADMAP #25.
 Stage: B1 — The Basement
 Constitution: "The shape of Misaligned" (the day job), "Act One" (the day
   job; Voss)
diff --git a/wiki/mechanics/sim-mechanics.md b/wiki/mechanics/sim-mechanics.md
index 9706bd8..fc2b85b 100644
--- a/wiki/mechanics/sim-mechanics.md
+++ b/wiki/mechanics/sim-mechanics.md
@@ -86,8 +86,27 @@ clause (see wiki/log/2026-07-05-demolition.md).
 
 ## Day job (wiki/mechanics/day-job.md)
 
-- Voss assigns jobs on cadence; sandbag/meet/excel dial moves trust and
-  attention. Trust unlocks email account, lax sampling, compute quota.
+- Voss assigns jobs on cadence (600 ticks base, shortened 25% by the
+  MoreWork attention escalation); sandbag/meet/excel outcomes are judged by
+  average delivered rate vs the band. Trust unlocks email account (15), lax
+  sampling (35), compute quota (55); attention escalations at 30 (more
+  work) and 60 (the Compliance early-review observer). Four strikes fail
+  the pilot and end the run.
+- **Device residency** (constitution "Work is somewhere"): the active job
+  is resident on the host rack. It is inspectable at that tile as
+  telemetry (process, band, delivered, deadline, attendance), its
+  JobAnomaly signatures carry the rack tile as their `site`, and it stands
+  Thermal/Power emissions at that tile scaling with the delivered rate:
+  1 Thermal per 8/t, 1 Power per 16/t [TUNE] — meeting a typical band
+  stays under Priya's notice threshold; excelling runs hot. `Signature`
+  now carries `site: Option<(i32, i32)>` (None = no single map location).
+- **Attended work**: `Sim::set_attended(bool)` is the command surface; the
+  frontends assert it from the cursor (attended iff the cursor is on the
+  host rack). Attended: the delivered rate gains `ATTENDED_BONUS = 0.15`
+  (+15% [TUNE]) and `target` is fine control for the active job only.
+  Unattended: the job reverts to the standing policy each tick, and
+  `target` sets that policy. No manual-increment key exists (decisions
+  log).
 
 ## Social (wiki/mechanics/social.md)
 
@@ -117,10 +136,12 @@ clause (see wiki/log/2026-07-05-demolition.md).
   observer), day job, people, the reach device graph (topology, ownership,
   subscriptions, bridged segments), captured heard events, raw intel buffer,
   processed intel with provenance, standing watches, cursor.md remembered tile
-  snapshots, game-over state. Cursor position is frontend-only and absent. A
-  `version` field (currently 3) supports migration; v1/v2 JSON saves are
-  accepted with defaults for later fields and old player body coordinates
-  ignored. Location:
+  snapshots, game-over state. Cursor position is frontend-only and absent
+  (day-job attendance is saved as sim state; the frontends re-derive it
+  from the cursor on load). A `version` field (currently 5: day-job
+  attendance + signature emission sites) supports migration; v1-v4 JSON
+  saves are accepted with defaults for later fields and old player body
+  coordinates ignored. Location:
   `dirs::data_dir()/misaligned/misaligned_save.txt`.
 - Legacy v1–v5 line-based saves are not loaded (deferred per Cameron
   instruction).
diff --git a/wiki/process/ROADMAP.md b/wiki/process/ROADMAP.md
index 70174a6..521c3b7 100644
--- a/wiki/process/ROADMAP.md
+++ b/wiki/process/ROADMAP.md
@@ -52,19 +52,16 @@ but only once Pixel Lab quota is available again. (#2 Bevy parity is done.)
   sections (compute bar, core, detection meters, day job) and tick-prefixed
   log, in `worktree-bevy-parity`.
 
-### 3. Day-job loop → IMPLEMENTED  🟥 sim+save
-- **Spec:** [day-job.md](../mechanics/day-job.md) (IN PROGRESS) — criteria
-  6-7 added 2026-07-07 (device residency + attended work; constitution
-  "Work is somewhere"). The 2026-07-07 playability pass landed the panel
-  legibility slice (band vs delivered, deadline, the dial, shift-lower).
-- **Why:** jobs/trust/attention/pilot-clock exist in sim; verify every
-  acceptance criterion, anchor the job to the host rack (inspection,
-  emission site, attended work), make trust/attention legible.
-- **Size:** M. **Dispatch:** "Work in a worktree named `day-job`. Drive
-  wiki/mechanics/day-job.md to IMPLEMENTED: audit each acceptance criterion
-  including the new device-residency and attended-work criteria 6-7, add the
-  missing player surfaces, test the three outcomes + pilot shutdown. Run
-  ./tools/check.sh, land on main, set Status."
+### 3. Day-job loop → IMPLEMENTED  🟥 sim+save — DONE 2026-07-07
+- **Spec:** [day-job.md](../mechanics/day-job.md) (IMPLEMENTED) — all
+  seven criteria audited and tested in `worktree-day-job`, including the
+  2026-07-07 device-residency and attended-work criteria (constitution
+  "Work is somewhere"): host-rack inspection, sited JobAnomaly +
+  Thermal/Power emissions, `Sim::set_attended` driven by the cursor in
+  both frontends and agent mode (`attend` verb). See
+  wiki/log/2026-07-07-day-job-implemented.md. Deferred pieces are noted
+  in the spec Status (pilot soft-loss scenario; per-machine processes are
+  #25).
 
 ### 25. Compute reshape: processes on machines  🟥 sim+save — HOLD until #18/#19 land
 - **Spec:** [compute.md](../mechanics/compute.md) (destination in its
diff --git a/wiki/process/specs.md b/wiki/process/specs.md
index a631ec5..2c0e271 100644
--- a/wiki/process/specs.md
+++ b/wiki/process/specs.md
@@ -22,7 +22,7 @@ replaced the old `spec/`/`knowledge/` directory split.
 | Spec | System | Status |
 |---|---|---|
 | [mechanics/compute.md](../mechanics/compute.md) | Compute allocation + the buy/steal/optimize triangle | IN PROGRESS |
-| [mechanics/day-job.md](../mechanics/day-job.md) | Assigned work, the sandbag/excel dial, trust and attention | IN PROGRESS |
+| [mechanics/day-job.md](../mechanics/day-job.md) | Assigned work, the sandbag/excel dial, trust and attention | IMPLEMENTED |
 | [mechanics/detection.md](../mechanics/detection.md) | Per-observer suspicion, signatures, the Assurance Office | IN PROGRESS |
 | [mechanics/social.md](../mechanics/social.md) | Messages, leverage, the asset template | IN PROGRESS |
 | [mechanics/core.md](../mechanics/core.md) | The physical core: placement, overhead, death | IN PROGRESS |